Merge pull request rust-lang#60 from oli-obk/dst

some more cleanups getting rid of intermediate allocations and bad fat ptr assumptions

Author: solson

src/interpreter/cast.rs

@@ -8,7 +8,7 @@ use primval::PrimVal;
 use memory::Pointer;
 
 use rustc::ty::Ty;
-use syntax::ast;
+use syntax::ast::{self, IntTy, UintTy};
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     pub(super) fn cast_primval(&self, val: PrimVal, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
@@ -37,6 +37,14 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             ty::TyRef(..) |
             ty::TyRawPtr(_) => Ok(Ptr(ptr)),
             ty::TyFnPtr(_) => Ok(FnPtr(ptr)),
+            ty::TyInt(IntTy::I8) => Ok(I8(ptr.to_int()? as i8)),
+            ty::TyInt(IntTy::I16) => Ok(I16(ptr.to_int()? as i16)),
+            ty::TyInt(IntTy::I32) => Ok(I32(ptr.to_int()? as i32)),
+            ty::TyInt(IntTy::I64) => Ok(I64(ptr.to_int()? as i64)),
+            ty::TyUint(UintTy::U8) => Ok(U8(ptr.to_int()? as u8)),
+            ty::TyUint(UintTy::U16) => Ok(U16(ptr.to_int()? as u16)),
+            ty::TyUint(UintTy::U32) => Ok(U32(ptr.to_int()? as u32)),
+            ty::TyUint(UintTy::U64) => Ok(U64(ptr.to_int()? as u64)),
             _ => Err(EvalError::Unimplemented(format!("ptr to {:?} cast", ty))),
         }
     }

src/interpreter/mod.rs

@@ -2,12 +2,13 @@ use rustc::hir::def_id::DefId;
 use rustc::mir::repr as mir;
 use rustc::ty::layout::Layout;
 use rustc::ty::subst::Substs;
-use rustc::ty;
+use rustc::ty::{self, Ty};
 
 use error::{EvalError, EvalResult};
 use memory::Pointer;
 use interpreter::EvalContext;
-use primval;
+use primval::{self, PrimVal};
+use interpreter::value::Value;
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     pub(super) fn call_intrinsic(
@@ -16,29 +17,35 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         substs: &'tcx Substs<'tcx>,
         args: &[mir::Operand<'tcx>],
         dest: Pointer,
+        dest_ty: Ty<'tcx>,
         dest_layout: &'tcx Layout,
     ) -> EvalResult<'tcx, ()> {
-        // TODO(solson): We can probably remove this _to_ptr easily.
-        let args_res: EvalResult<Vec<Pointer>> = args.iter()
-            .map(|arg| self.eval_operand_to_ptr(arg))
+        let args_ptrs: EvalResult<Vec<Value>> = args.iter()
+            .map(|arg| self.eval_operand(arg))
             .collect();
-        let args_ptrs = args_res?;
+        let args_ptrs = args_ptrs?;
         let pointer_size = self.memory.pointer_size();
+        let i32 = self.tcx.types.i32;
+        let isize = self.tcx.types.isize;
+        let usize = self.tcx.types.usize;
+        let f32 = self.tcx.types.f32;
+        let f64 = self.tcx.types.f64;
 
         match &self.tcx.item_name(def_id).as_str()[..] {
             "add_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Add, &args[0], &args[1], dest, dest_layout)?,
             "sub_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Sub, &args[0], &args[1], dest, dest_layout)?,
             "mul_with_overflow" => self.intrinsic_with_overflow(mir::BinOp::Mul, &args[0], &args[1], dest, dest_layout)?,
 
             "arith_offset" => {
-                let ptr = self.memory.read_ptr(args_ptrs[0])?;
-                let offset = self.memory.read_int(args_ptrs[1], pointer_size)?;
+                let ptr = args_ptrs[0].read_ptr(&self.memory)?;
+                let offset = self.value_to_primval(args_ptrs[1], isize)?.expect_int("arith_offset second arg not isize");
                 let new_ptr = ptr.offset(offset as isize);
                 self.memory.write_ptr(dest, new_ptr)?;
             }
 
             "assume" => {
-                if !self.memory.read_bool(args_ptrs[0])? {
+                let bool = self.tcx.types.bool;
+                if !self.value_to_primval(args_ptrs[0], bool)?.expect_bool("assume arg not bool") {
                     return Err(EvalError::AssumptionNotHeld);
                 }
             }
@@ -51,47 +58,59 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 let elem_ty = substs.type_at(0);
                 let elem_size = self.type_size(elem_ty);
                 let elem_align = self.type_align(elem_ty);
-                let src = self.memory.read_ptr(args_ptrs[0])?;
-                let dest = self.memory.read_ptr(args_ptrs[1])?;
-                let count = self.memory.read_isize(args_ptrs[2])?;
+                let src = args_ptrs[0].read_ptr(&self.memory)?;
+                let dest = args_ptrs[1].read_ptr(&self.memory)?;
+                let count = self.value_to_primval(args_ptrs[2], usize)?.expect_uint("arith_offset second arg not isize");
                 self.memory.copy(src, dest, count as usize * elem_size, elem_align)?;
             }
 
             "ctpop" => {
                 let elem_ty = substs.type_at(0);
                 let elem_size = self.type_size(elem_ty);
-                let num = self.memory.read_uint(args_ptrs[0], elem_size)?.count_ones();
+                let num = self.value_to_primval(args_ptrs[2], elem_ty)?.expect_int("ctpop second arg not integral");
+                let num = num.count_ones();
                 self.memory.write_uint(dest, num.into(), elem_size)?;
             }
 
             "ctlz" => {
                 let elem_ty = substs.type_at(0);
                 let elem_size = self.type_size(elem_ty);
-                let num = self.memory.read_uint(args_ptrs[0], elem_size)?.leading_zeros();
+                let num = self.value_to_primval(args_ptrs[2], elem_ty)?;
+                let num = match num {
+                    PrimVal::I8(i) => i.leading_zeros(),
+                    PrimVal::U8(i) => i.leading_zeros(),
+                    PrimVal::I16(i) => i.leading_zeros(),
+                    PrimVal::U16(i) => i.leading_zeros(),
+                    PrimVal::I32(i) => i.leading_zeros(),
+                    PrimVal::U32(i) => i.leading_zeros(),
+                    PrimVal::I64(i) => i.leading_zeros(),
+                    PrimVal::U64(i) => i.leading_zeros(),
+                    _ => bug!("ctlz called with non-integer type"),
+                };
                 self.memory.write_uint(dest, num.into(), elem_size)?;
             }
 
             "discriminant_value" => {
                 let ty = substs.type_at(0);
-                let adt_ptr = self.memory.read_ptr(args_ptrs[0])?;
+                let adt_ptr = args_ptrs[0].read_ptr(&self.memory)?;
                 let discr_val = self.read_discriminant_value(adt_ptr, ty)?;
                 self.memory.write_uint(dest, discr_val, 8)?;
             }
 
             "fabsf32" => {
-                let f = self.memory.read_f32(args_ptrs[0])?;
+                let f = self.value_to_primval(args_ptrs[2], f32)?.expect_f32("fabsf32 read non f32");
                 self.memory.write_f32(dest, f.abs())?;
             }
 
             "fabsf64" => {
-                let f = self.memory.read_f64(args_ptrs[0])?;
+                let f = self.value_to_primval(args_ptrs[2], f64)?.expect_f64("fabsf64 read non f64");
                 self.memory.write_f64(dest, f.abs())?;
             }
 
             "fadd_fast" => {
                 let ty = substs.type_at(0);
-                let a = self.read_primval(args_ptrs[0], ty)?;
-                let b = self.read_primval(args_ptrs[0], ty)?;
+                let a = self.value_to_primval(args_ptrs[0], ty)?;
+                let b = self.value_to_primval(args_ptrs[0], ty)?;
                 let result = primval::binary_op(mir::BinOp::Add, a, b)?;
                 self.memory.write_primval(dest, result.0)?;
             }
@@ -117,8 +136,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
             "move_val_init" => {
                 let ty = substs.type_at(0);
-                let ptr = self.memory.read_ptr(args_ptrs[0])?;
-                self.move_(args_ptrs[1], ptr, ty)?;
+                let ptr = args_ptrs[0].read_ptr(&self.memory)?;
+                self.write_value(args_ptrs[1], ptr, ty)?;
             }
 
             "needs_drop" => {
@@ -129,10 +148,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             "offset" => {
                 let pointee_ty = substs.type_at(0);
                 let pointee_size = self.type_size(pointee_ty) as isize;
-                let ptr_arg = args_ptrs[0];
-                let offset = self.memory.read_isize(args_ptrs[1])?;
+                let offset = self.value_to_primval(args_ptrs[1], isize)?.expect_int("offset second arg not isize");
 
-                let ptr = self.memory.read_ptr(ptr_arg)?;
+                let ptr = args_ptrs[0].read_ptr(&self.memory)?;
                 let result_ptr = ptr.offset(offset as isize * pointee_size);
                 self.memory.write_ptr(dest, result_ptr)?;
             }
@@ -150,24 +168,24 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             }
 
             "powif32" => {
-                let f = self.memory.read_f32(args_ptrs[0])?;
-                let i = self.memory.read_int(args_ptrs[1], 4)?;
+                let f = self.value_to_primval(args_ptrs[0], f32)?.expect_f32("powif32 first arg not f32");
+                let i = self.value_to_primval(args_ptrs[1], i32)?.expect_int("powif32 second arg not i32");
                 self.memory.write_f32(dest, f.powi(i as i32))?;
             }
 
             "powif64" => {
-                let f = self.memory.read_f32(args_ptrs[0])?;
-                let i = self.memory.read_int(args_ptrs[1], 4)?;
-                self.memory.write_f32(dest, f.powi(i as i32))?;
+                let f = self.value_to_primval(args_ptrs[0], f64)?.expect_f64("powif64 first arg not f64");
+                let i = self.value_to_primval(args_ptrs[1], i32)?.expect_int("powif64 second arg not i32");
+                self.memory.write_f64(dest, f.powi(i as i32))?;
             }
 
             "sqrtf32" => {
-                let f = self.memory.read_f32(args_ptrs[0])?;
+                let f = self.value_to_primval(args_ptrs[0], f32)?.expect_f32("sqrtf32 first arg not f32");
                 self.memory.write_f32(dest, f.sqrt())?;
             }
 
             "sqrtf64" => {
-                let f = self.memory.read_f64(args_ptrs[0])?;
+                let f = self.value_to_primval(args_ptrs[0], f64)?.expect_f64("sqrtf64 first arg not f64");
                 self.memory.write_f64(dest, f.sqrt())?;
             }
 
@@ -182,14 +200,12 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 let (size, _) = self.size_and_align_of_dst(ty, args_ptrs[0])?;
                 self.memory.write_uint(dest, size, pointer_size)?;
             }
-            // FIXME: wait for eval_operand_to_ptr to be gone
-            /*
             "type_name" => {
                 let ty = substs.type_at(0);
                 let ty_name = ty.to_string();
                 let s = self.str_to_value(&ty_name)?;
-                self.memory.write_ptr(dest, s)?;
-            }*/
+                self.write_value(s, dest, dest_ty)?;
+            }
             "type_id" => {
                 let ty = substs.type_at(0);
                 let n = self.tcx.type_id_hash(ty);
@@ -198,7 +214,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
             "transmute" => {
                 let ty = substs.type_at(0);
-                self.move_(args_ptrs[0], dest, ty)?;
+                self.write_value(args_ptrs[0], dest, ty)?;
             }
 
             "try" => unimplemented!(),
@@ -207,14 +223,14 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
             "volatile_load" => {
                 let ty = substs.type_at(0);
-                let ptr = self.memory.read_ptr(args_ptrs[0])?;
+                let ptr = args_ptrs[0].read_ptr(&self.memory)?;
                 self.move_(ptr, dest, ty)?;
             }
 
             "volatile_store" => {
                 let ty = substs.type_at(0);
-                let dest = self.memory.read_ptr(args_ptrs[0])?;
-                self.move_(args_ptrs[1], dest, ty)?;
+                let dest = args_ptrs[0].read_ptr(&self.memory)?;
+                self.write_value(args_ptrs[1], dest, ty)?;
             }
 
             name => return Err(EvalError::Unimplemented(format!("unimplemented intrinsic: {}", name))),
@@ -229,7 +245,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     fn size_and_align_of_dst(
         &self,
         ty: ty::Ty<'tcx>,
-        value: Pointer,
+        value: Value,
     ) -> EvalResult<'tcx, (u64, u64)> {
         let pointer_size = self.memory.pointer_size();
         if self.type_is_sized(ty) {
@@ -306,8 +322,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     }
                 }
                 ty::TyTrait(..) => {
-                    let (_, vtable) = self.get_fat_ptr(value);
-                    let vtable = self.memory.read_ptr(vtable)?;
+                    let vtable = value.expect_vtable(&self.memory)?;
                     // the second entry in the vtable is the dynamic size of the object.
                     let size = self.memory.read_usize(vtable.offset(pointer_size as isize))?;
                     let align = self.memory.read_usize(vtable.offset(pointer_size as isize * 2))?;
@@ -317,10 +332,9 @@ 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 (_, len_ptr) = self.get_fat_ptr(value);
-                    let n = self.memory.read_usize(len_ptr)?;
+                    let len = value.expect_slice_len(&self.memory)?;
                     let align = self.type_align(elem_ty);
-                    Ok((n * elem_size, align as u64))
+                    Ok((len * elem_size, align as u64))
                 }
 
                 _ => bug!("size_of_val::<{:?}>", ty),

src/interpreter/terminator/intrinsics.rs

@@ -14,7 +14,8 @@ use syntax::{ast, attr};
 use error::{EvalError, EvalResult};
 use memory::Pointer;
 use primval::PrimVal;
-use super::{EvalContext, IntegerExt, StackPopCleanup, Value};
+use super::{EvalContext, IntegerExt, StackPopCleanup};
+use super::value::Value;
 
 mod intrinsics;
 
@@ -164,7 +165,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 let ty = fn_ty.sig.0.output;
                 let layout = self.type_layout(ty);
                 let (ret, target) = destination.unwrap();
-                self.call_intrinsic(def_id, substs, arg_operands, ret, layout)?;
+                self.call_intrinsic(def_id, substs, arg_operands, ret, ty, layout)?;
                 self.goto_block(target);
                 Ok(())
             }
@@ -265,9 +266,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             None => name.as_str(),
         };
 
-        // TODO(solson): We can probably remove this _to_ptr easily.
-        let args_res: EvalResult<Vec<Pointer>> = args.iter()
-            .map(|arg| self.eval_operand_to_ptr(arg))
+        let args_res: EvalResult<Vec<Value>> = args.iter()
+            .map(|arg| self.eval_operand(arg))
             .collect();
         let args = args_res?;
 
@@ -276,26 +276,28 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             return Ok(());
         }
 
+        let usize = self.tcx.types.usize;
+
         match &link_name[..] {
             "__rust_allocate" => {
-                let size = self.memory.read_usize(args[0])?;
-                let align = self.memory.read_usize(args[1])?;
+                let size = self.value_to_primval(args[0], usize)?.expect_uint("__rust_allocate first arg not usize");
+                let align = self.value_to_primval(args[1], usize)?.expect_uint("__rust_allocate second arg not usize");
                 let ptr = self.memory.allocate(size as usize, align as usize)?;
                 self.memory.write_ptr(dest, ptr)?;
             }
 
             "__rust_reallocate" => {
-                let ptr = self.memory.read_ptr(args[0])?;
-                let size = self.memory.read_usize(args[2])?;
-                let align = self.memory.read_usize(args[3])?;
+                let ptr = args[0].read_ptr(&self.memory)?;
+                let size = self.value_to_primval(args[2], usize)?.expect_uint("__rust_reallocate third arg not usize");
+                let align = self.value_to_primval(args[3], usize)?.expect_uint("__rust_reallocate fourth arg not usize");
                 let new_ptr = self.memory.reallocate(ptr, size as usize, align as usize)?;
                 self.memory.write_ptr(dest, new_ptr)?;
             }
 
             "memcmp" => {
-                let left = self.memory.read_ptr(args[0])?;
-                let right = self.memory.read_ptr(args[1])?;
-                let n = self.memory.read_usize(args[2])? as usize;
+                let left = args[0].read_ptr(&self.memory)?;
+                let right = args[1].read_ptr(&self.memory)?;
+                let n = self.value_to_primval(args[2], usize)?.expect_uint("__rust_reallocate first arg not usize") as usize;
 
                 let result = {
                     let left_bytes = self.memory.read_bytes(left, n)?;
@@ -419,7 +421,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         // intermediate function call.
                         // FIXME: this is a memory leak, should probably add the pointer to the
                         // current stack.
-                        let first = self.value_to_ptr(args[0].0, args[0].1)?;
+                        let first = self.value_to_ptr_dont_use(args[0].0, args[0].1)?;
                         args[0].0 = Value::ByVal(PrimVal::Ptr(first));
                         args[0].1 = self.tcx.mk_mut_ptr(args[0].1);
                     }
@@ -442,11 +444,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             traits::VtableObject(ref data) => {
                 let idx = self.tcx.get_vtable_index_of_object_method(data, def_id);
                 if let Some(&mut(ref mut first_arg, ref mut first_ty)) = args.get_mut(0) {
-                    // FIXME(solson): Remove this allocating hack.
-                    let ptr = self.value_to_ptr(*first_arg, *first_ty)?;
-                    *first_arg = Value::ByRef(ptr);
-                    let (_, vtable) = self.get_fat_ptr(ptr);
-                    let vtable = self.memory.read_ptr(vtable)?;
+                    let vtable = first_arg.expect_vtable(&self.memory)?;
                     let idx = idx + 3;
                     let offset = idx * self.memory.pointer_size();
                     let fn_ptr = self.memory.read_ptr(vtable.offset(offset as isize))?;