Simplify Repr::Array's elem size.

diff --git a/src/interpreter.rs b/src/interpreter.rs
index 8741beb8735a9aa4abb5085962bf54c765644e9e..9c5e505671afcfc1447dba6baeb75c17d3ce96bd 100644 (file)
--- a/src/interpreter.rs
+++ b/src/interpreter.rs
@@ -372,9 +372,8 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
                     },
 
                     Vec => match dest_repr {
-                        Repr::Array { ref elem, length } => {
+                        Repr::Array { elem_size, length } => {
                             assert_eq!(length, operands.len());
-                            let elem_size = elem.size();
                             for (i, operand) in operands.iter().enumerate() {
                                 let src = try!(self.eval_operand(operand));
                                 let offset = i * elem_size;
@@ -396,8 +395,8 @@ fn eval_assignment(&mut self, lvalue: &mir::Lvalue<'tcx>, rvalue: &mir::Rvalue<'
             }
 
             Box(ty) => {
-                let repr = self.ty_to_repr(ty);
-                let ptr = self.memory.allocate(repr.size());
+                let size = self.ty_to_repr(ty).size();
+                let ptr = self.memory.allocate(size);
                 self.memory.write_ptr(dest, ptr)
             }
 
@@ -538,7 +537,7 @@ fn const_to_ptr(&mut self, const_val: &const_eval::ConstVal) -> EvalResult<Point
             Str(ref _s) => unimplemented!(),
             ByteStr(ref _bs) => unimplemented!(),
             Bool(b) => {
-                let ptr = self.memory.allocate(Repr::Bool.size());
+                let ptr = self.memory.allocate(1);
                 try!(self.memory.write_bool(ptr, b));
                 Ok(ptr)
             }
@@ -616,7 +615,7 @@ fn ty_to_repr(&self, ty: ty::Ty<'tcx>) -> Repr {
             }
 
             ty::TyArray(ref elem_ty, length) => Repr::Array {
-                elem: Box::new(self.ty_to_repr(elem_ty)),
+                elem_size: self.ty_to_repr(elem_ty).size(),
                 length: length,
             },
 
@@ -786,8 +785,8 @@ fn print_allocation_tree(memory: &Memory, alloc_id: memory::AllocId) {
                 let mut miri = Interpreter::new(tcx, mir_map);
                 let return_ptr = match mir.return_ty {
                     ty::FnConverging(ty) => {
-                        let repr = miri.ty_to_repr(ty).size();
-                        Some(miri.memory.allocate(repr))
+                        let size = miri.ty_to_repr(ty).size();
+                        Some(miri.memory.allocate(size))
                     }
                     ty::FnDiverging => None,
                 };

diff --git a/src/memory.rs b/src/memory.rs
index 17e9439de6d8ced86da0844edd8e06de3f7e3986..a42d504381ae72bb5261d6a4c240bb6bf52ad422 100644 (file)
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -68,7 +68,7 @@ pub enum Repr {
     },
 
     Array {
-        elem: Box<Repr>,
+        elem_size: usize,
 
         /// Number of elements.
         length: usize,
@@ -386,7 +386,7 @@ pub fn size(&self) -> usize {
             Repr::I64 | Repr::U64 => 8,
             Repr::Product { size, .. } => size,
             Repr::Sum { discr_size, max_variant_size, .. } => discr_size + max_variant_size,
-            Repr::Array { ref elem, length } => elem.size() * length,
+            Repr::Array { elem_size, length } => elem_size * length,
             Repr::Pointer => POINTER_SIZE,
             Repr::FatPointer => POINTER_SIZE * 2,
         }