Merge pull request rust-lang#64 from oli-obk/bugfixes

Bugfixes

Author: solson

src/error.rs

@@ -9,6 +9,7 @@ use syntax::codemap::Span;
 #[derive(Clone, Debug)]
 pub enum EvalError<'tcx> {
     FunctionPointerTyMismatch(&'tcx BareFnTy<'tcx>, &'tcx BareFnTy<'tcx>),
+    NoMirFor(String),
     DanglingPointerDeref,
     InvalidMemoryAccess,
     InvalidFunctionPointer,
@@ -82,6 +83,8 @@ impl<'tcx> Error for EvalError<'tcx> {
                 "array index out of bounds",
             EvalError::Math(..) =>
                 "mathematical operation failed",
+            EvalError::NoMirFor(..) =>
+                "mir not found",
             EvalError::InvalidChar(..) =>
                 "tried to interpret an invalid 32-bit value as a char",
             EvalError::OutOfMemory{..} =>
@@ -113,6 +116,7 @@ impl<'tcx> fmt::Display for EvalError<'tcx> {
                 write!(f, "memory access of {}..{} outside bounds of allocation {} which has size {}",
                        ptr.offset, ptr.offset + size, ptr.alloc_id, allocation_size)
             },
+            EvalError::NoMirFor(ref func) => write!(f, "no mir for `{}`", func),
             EvalError::FunctionPointerTyMismatch(expected, got) =>
                 write!(f, "tried to call a function of type {:?} through a function pointer of type {:?}", expected, got),
             EvalError::ArrayIndexOutOfBounds(span, len, index) =>

src/interpreter/mod.rs

@@ -267,25 +267,33 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         ty.is_sized(self.tcx, &self.tcx.empty_parameter_environment(), DUMMY_SP)
     }
 
-    pub fn load_mir(&self, def_id: DefId) -> CachedMir<'a, 'tcx> {
+    pub fn load_mir(&self, def_id: DefId) -> EvalResult<'tcx, CachedMir<'a, 'tcx>> {
+        trace!("load mir {:?}", def_id);
         if def_id.is_local() {
-            CachedMir::Ref(self.mir_map.map.get(&def_id).unwrap())
+            Ok(CachedMir::Ref(self.mir_map.map.get(&def_id).unwrap()))
         } else {
             let mut mir_cache = self.mir_cache.borrow_mut();
             if let Some(mir) = mir_cache.get(&def_id) {
-                return CachedMir::Owned(mir.clone());
+                return Ok(CachedMir::Owned(mir.clone()));
             }
 
             let cs = &self.tcx.sess.cstore;
-            let mir = cs.maybe_get_item_mir(self.tcx, def_id).unwrap_or_else(|| {
-                panic!("no mir for `{}`", self.tcx.item_path_str(def_id));
-            });
-            let cached = Rc::new(mir);
-            mir_cache.insert(def_id, cached.clone());
-            CachedMir::Owned(cached)
+            match cs.maybe_get_item_mir(self.tcx, def_id) {
+                Some(mir) => {
+                    let cached = Rc::new(mir);
+                    mir_cache.insert(def_id, cached.clone());
+                    Ok(CachedMir::Owned(cached))
+                },
+                None => Err(EvalError::NoMirFor(self.tcx.item_path_str(def_id))),
+            }
         }
     }
 
+    pub fn monomorphize_field_ty(&self, f: ty::FieldDef<'tcx>, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
+        let substituted = &f.ty(self.tcx, substs);
+        self.tcx.normalize_associated_type(&substituted)
+    }
+
     pub fn monomorphize(&self, ty: Ty<'tcx>, substs: &'tcx Substs<'tcx>) -> Ty<'tcx> {
         let substituted = ty.subst(self.tcx, substs);
         self.tcx.normalize_associated_type(&substituted)
@@ -519,7 +527,10 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                                     .chain(nonnull.offset_after_field.iter().map(|s| s.bytes()));
                                 try!(self.assign_fields(dest, offsets, operands));
                             } else {
-                                assert_eq!(operands.len(), 0);
+                                for operand in operands {
+                                    let operand_ty = self.operand_ty(operand);
+                                    assert_eq!(self.type_size(operand_ty), 0);
+                                }
                                 let offset = self.nonnull_offset(dest_ty, nndiscr, discrfield)?;
                                 let dest = dest.offset(offset.bytes() as isize);
                                 try!(self.memory.write_isize(dest, 0));
@@ -596,56 +607,19 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 self.memory.write_ptr(dest, ptr)?;
             }
 
-            Cast(kind, ref operand, dest_ty) => {
+            Cast(kind, ref operand, cast_ty) => {
+                debug_assert_eq!(self.monomorphize(cast_ty, self.substs()), dest_ty);
                 use rustc::mir::repr::CastKind::*;
                 match kind {
                     Unsize => {
                         let src = self.eval_operand(operand)?;
                         let src_ty = self.operand_ty(operand);
-                        let dest_ty = self.monomorphize(dest_ty, self.substs());
-                        // FIXME: cases where dest_ty is not a fat pointer. e.g. Arc<Struct> -> Arc<Trait>
-                        assert!(self.type_is_fat_ptr(dest_ty));
-                        let src_pointee_ty = pointee_type(src_ty).unwrap();
-                        let dest_pointee_ty = pointee_type(dest_ty).unwrap();
-
-                        // A<Struct> -> A<Trait> conversion
-                        let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(src_pointee_ty, dest_pointee_ty);
-
-                        match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
-                            (&ty::TyArray(_, length), &ty::TySlice(_)) => {
-                                let ptr = src.read_ptr(&self.memory)?;
-                                self.memory.write_ptr(dest, ptr)?;
-                                let ptr_size = self.memory.pointer_size() as isize;
-                                let dest_extra = dest.offset(ptr_size);
-                                self.memory.write_usize(dest_extra, length as u64)?;
-                            }
-                            (&ty::TyTrait(_), &ty::TyTrait(_)) => {
-                                // For now, upcasts are limited to changes in marker
-                                // traits, and hence never actually require an actual
-                                // change to the vtable.
-                                self.write_value(src, dest, dest_ty)?;
-                            },
-                            (_, &ty::TyTrait(ref data)) => {
-                                let trait_ref = data.principal.with_self_ty(self.tcx, src_pointee_ty);
-                                let trait_ref = self.tcx.erase_regions(&trait_ref);
-                                let vtable = self.get_vtable(trait_ref)?;
-                                let ptr = src.read_ptr(&self.memory)?;
-
-                                self.memory.write_ptr(dest, ptr)?;
-                                let ptr_size = self.memory.pointer_size() as isize;
-                                let dest_extra = dest.offset(ptr_size);
-                                self.memory.write_ptr(dest_extra, vtable)?;
-                            },
-
-                            _ => bug!("invalid unsizing {:?} -> {:?}", src_ty, dest_ty),
-                        }
+                        self.unsize_into(src, src_ty, dest, dest_ty)?;
                     }
 
                     Misc => {
                         let src = self.eval_operand(operand)?;
                         let src_ty = self.operand_ty(operand);
-                        // FIXME: dest_ty should already be monomorphized
-                        let dest_ty = self.monomorphize(dest_ty, self.substs());
                         if self.type_is_fat_ptr(src_ty) {
                             trace!("misc cast: {:?}", src);
                             let ptr_size = self.memory.pointer_size();
@@ -760,9 +734,8 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
         use rustc::ty::layout::Layout::*;
         match *layout {
-            Univariant { .. } => {
-                assert_eq!(field_index, 0);
-                Ok(Size::from_bytes(0))
+            Univariant { ref variant, .. } => {
+                Ok(variant.field_offset(field_index))
             }
             FatPointer { .. } => {
                 let bytes = layout::FAT_PTR_ADDR * self.memory.pointer_size();
@@ -1106,16 +1079,91 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     fn substs(&self) -> &'tcx Substs<'tcx> {
         self.frame().substs
     }
-}
 
-fn pointee_type(ptr_ty: ty::Ty) -> Option<ty::Ty> {
-    match ptr_ty.sty {
-        ty::TyRef(_, ty::TypeAndMut { ty, .. }) |
-        ty::TyRawPtr(ty::TypeAndMut { ty, .. }) |
-        ty::TyBox(ty) => {
-            Some(ty)
+    fn unsize_into(
+        &mut self,
+        src: Value,
+        src_ty: Ty<'tcx>,
+        dest: Pointer,
+        dest_ty: Ty<'tcx>,
+    ) -> EvalResult<'tcx, ()> {
+        match (&src_ty.sty, &dest_ty.sty) {
+            (&ty::TyBox(sty), &ty::TyBox(dty)) |
+            (&ty::TyRef(_, ty::TypeAndMut { ty: sty, .. }), &ty::TyRef(_, ty::TypeAndMut { ty: dty, .. })) |
+            (&ty::TyRef(_, ty::TypeAndMut { ty: sty, .. }), &ty::TyRawPtr(ty::TypeAndMut { ty: dty, .. })) |
+            (&ty::TyRawPtr(ty::TypeAndMut { ty: sty, .. }), &ty::TyRawPtr(ty::TypeAndMut { ty: dty, .. })) => {
+                // A<Struct> -> A<Trait> conversion
+                let (src_pointee_ty, dest_pointee_ty) = self.tcx.struct_lockstep_tails(sty, dty);
+
+                match (&src_pointee_ty.sty, &dest_pointee_ty.sty) {
+                    (&ty::TyArray(_, length), &ty::TySlice(_)) => {
+                        let ptr = src.read_ptr(&self.memory)?;
+                        self.memory.write_ptr(dest, ptr)?;
+                        let ptr_size = self.memory.pointer_size() as isize;
+                        let dest_extra = dest.offset(ptr_size);
+                        self.memory.write_usize(dest_extra, length as u64)?;
+                    }
+                    (&ty::TyTrait(_), &ty::TyTrait(_)) => {
+                        // For now, upcasts are limited to changes in marker
+                        // traits, and hence never actually require an actual
+                        // change to the vtable.
+                        self.write_value(src, dest, dest_ty)?;
+                    },
+                    (_, &ty::TyTrait(ref data)) => {
+                        let trait_ref = data.principal.with_self_ty(self.tcx, src_pointee_ty);
+                        let trait_ref = self.tcx.erase_regions(&trait_ref);
+                        let vtable = self.get_vtable(trait_ref)?;
+                        let ptr = src.read_ptr(&self.memory)?;
+
+                        self.memory.write_ptr(dest, ptr)?;
+                        let ptr_size = self.memory.pointer_size() as isize;
+                        let dest_extra = dest.offset(ptr_size);
+                        self.memory.write_ptr(dest_extra, vtable)?;
+                    },
+
+                    _ => bug!("invalid unsizing {:?} -> {:?}", src_ty, dest_ty),
+                }
+            }
+            (&ty::TyAdt(def_a, substs_a), &ty::TyAdt(def_b, substs_b)) => {
+                // unsizing of generic struct with pointer fields
+                // Example: `Arc<T>` -> `Arc<Trait>`
+                // here we need to increase the size of every &T thin ptr field to a fat ptr
+
+                assert_eq!(def_a, def_b);
+
+                let src_fields = def_a.variants[0].fields.iter();
+                let dst_fields = def_b.variants[0].fields.iter();
+
+                //let src = adt::MaybeSizedValue::sized(src);
+                //let dst = adt::MaybeSizedValue::sized(dst);
+                let src_ptr = match src {
+                    Value::ByRef(ptr) => ptr,
+                    _ => panic!("expected pointer, got {:?}", src),
+                };
+
+                let iter = src_fields.zip(dst_fields).enumerate();
+                for (i, (src_f, dst_f)) in iter {
+                    let src_fty = self.monomorphize_field_ty(src_f, substs_a);
+                    let dst_fty = self.monomorphize_field_ty(dst_f, substs_b);
+                    if self.type_size(dst_fty) == 0 {
+                        continue;
+                    }
+                    let src_field_offset = self.get_field_offset(src_ty, i)?.bytes() as isize;
+                    let dst_field_offset = self.get_field_offset(dest_ty, i)?.bytes() as isize;
+                    let src_f_ptr = src_ptr.offset(src_field_offset);
+                    let dst_f_ptr = dest.offset(dst_field_offset);
+                    if src_fty == dst_fty {
+                        self.move_(src_f_ptr, dst_f_ptr, src_fty)?;
+                    } else {
+                        self.unsize_into(Value::ByRef(src_f_ptr), src_fty, dst_f_ptr, dst_fty)?;
+                    }
+                }
+            }
+            _ => bug!("unsize_into: invalid conversion: {:?} -> {:?}",
+                      src_ty,
+                      dest_ty),
         }
-        _ => None,
+        Ok(())
     }
 }
 

src/interpreter/step.rs

@@ -125,8 +125,8 @@ impl<'a, 'b, 'tcx> ConstantExtractor<'a, 'b, 'tcx> {
         if self.ecx.statics.contains_key(&cid) {
             return;
         }
-        let mir = self.ecx.load_mir(def_id);
         self.try(|this| {
+            let mir = this.ecx.load_mir(def_id)?;
             let ptr = this.ecx.alloc_ret_ptr(mir.return_ty, substs)?;
             this.ecx.statics.insert(cid.clone(), ptr);
             let cleanup = if immutable && !mir.return_ty.type_contents(this.ecx.tcx).interior_unsafe() {
@@ -200,18 +200,25 @@ impl<'a, 'b, 'tcx> Visitor<'tcx> for ConstantExtractor<'a, 'b, 'tcx> {
         if let mir::Lvalue::Static(def_id) = *lvalue {
             let substs = subst::Substs::empty(self.ecx.tcx);
             let span = self.span;
-            let node_item = self.ecx.tcx.map.get_if_local(def_id).expect("static not found");
-            if let hir::map::Node::NodeItem(&hir::Item { ref node, .. }) = node_item {
-                if let hir::ItemStatic(_, m, _) = *node {
-                    self.global_item(def_id, substs, span, m == hir::MutImmutable);
-                    return;
+            if let Some(node_item) = self.ecx.tcx.map.get_if_local(def_id) {
+                if let hir::map::Node::NodeItem(&hir::Item { ref node, .. }) = node_item {
+                    if let hir::ItemStatic(_, m, _) = *node {
+                        self.global_item(def_id, substs, span, m == hir::MutImmutable);
+                        return;
+                    } else {
+                        bug!("static def id doesn't point to static");
+                    }
                 } else {
-                    bug!("static def id doesn't point to static");
+                    bug!("static def id doesn't point to item");
                 }
             } else {
-                bug!("static def id doesn't point to item");
+                let def = self.ecx.tcx.sess.cstore.describe_def(def_id).expect("static not found");
+                if let hir::def::Def::Static(_, mutable) = def {
+                    self.global_item(def_id, substs, span, !mutable);
+                } else {
+                    bug!("static found but isn't a static: {:?}", def);
+                }
             }
-            self.global_item(def_id, substs, span, false);
         }
     }
 }

src/interpreter/terminator/mod.rs

@@ -1,5 +1,4 @@
 use rustc::hir::def_id::DefId;
-use rustc::middle::const_val::ConstVal;
 use rustc::mir::repr as mir;
 use rustc::traits::{self, Reveal};
 use rustc::ty::fold::TypeFoldable;
@@ -45,26 +44,16 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             SwitchInt { ref discr, ref values, ref targets, .. } => {
                 let discr_ptr = self.eval_lvalue(discr)?.to_ptr();
                 let discr_ty = self.lvalue_ty(discr);
-                let discr_size = self
-                    .type_layout(discr_ty)
-                    .size(&self.tcx.data_layout)
-                    .bytes() as usize;
-                let discr_val = self.memory.read_uint(discr_ptr, discr_size)?;
-                if let ty::TyChar = discr_ty.sty {
-                    if ::std::char::from_u32(discr_val as u32).is_none() {
-                        return Err(EvalError::InvalidChar(discr_val as u64));
-                    }
-                }
+                let discr_val = self.read_value(discr_ptr, discr_ty)?;
+                let discr_prim = self.value_to_primval(discr_val, discr_ty)?;
 
                 // Branch to the `otherwise` case by default, if no match is found.
                 let mut target_block = targets[targets.len() - 1];
 
                 for (index, const_val) in values.iter().enumerate() {
-                    let val = match const_val {
-                        &ConstVal::Integral(i) => i.to_u64_unchecked(),
-                        _ => bug!("TerminatorKind::SwitchInt branch constant was not an integer"),
-                    };
-                    if discr_val == val {
+                    let val = self.const_to_value(const_val)?;
+                    let prim = self.value_to_primval(val, discr_ty)?;
+                    if discr_prim == prim {
                         target_block = targets[index];
                         break;
                     }
@@ -195,7 +184,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         (def_id, substs)
                     };
 
-                let mir = self.load_mir(resolved_def_id);
+                let mir = self.load_mir(resolved_def_id)?;
                 let (return_ptr, return_to_block) = match destination {
                     Some((ptr, block)) => (Some(ptr), StackPopCleanup::Goto(block)),
                     None => (None, StackPopCleanup::None),

src/interpreter/vtable.rs

@@ -112,35 +112,25 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
         self.tcx.populate_implementations_for_trait_if_necessary(trait_id);
 
-        let trait_item_def_ids = self.tcx.trait_item_def_ids(trait_id);
+        let trait_item_def_ids = self.tcx.impl_or_trait_items(trait_id);
         trait_item_def_ids
             .iter()
 
             // Filter out non-method items.
-            .filter_map(|item_def_id| {
-                match *item_def_id {
-                    ty::MethodTraitItemId(def_id) => Some(def_id),
-                    _ => None,
-                }
-            })
-
-            // Now produce pointers for each remaining method. If the
-            // method could never be called from this object, just supply
-            // null.
-            .map(|trait_method_def_id| {
+            .filter_map(|&trait_method_def_id| {
+                let trait_method_type = match self.tcx.impl_or_trait_item(trait_method_def_id) {
+                    ty::MethodTraitItem(trait_method_type) => trait_method_type,
+                    _ => return None,
+                };
                 debug!("get_vtable_methods: trait_method_def_id={:?}",
                        trait_method_def_id);
 
-                let trait_method_type = match self.tcx.impl_or_trait_item(trait_method_def_id) {
-                    ty::MethodTraitItem(m) => m,
-                    _ => bug!("should be a method, not other assoc item"),
-                };
                 let name = trait_method_type.name;
 
                 // Some methods cannot be called on an object; skip those.
                 if !self.tcx.is_vtable_safe_method(trait_id, &trait_method_type) {
                     debug!("get_vtable_methods: not vtable safe");
-                    return None;
+                    return Some(None);
                 }
 
                 debug!("get_vtable_methods: trait_method_type={:?}",
@@ -167,11 +157,11 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     let predicates = mth.method.predicates.predicates.subst(self.tcx, mth.substs);
                     if !self.normalize_and_test_predicates(predicates) {
                         debug!("get_vtable_methods: predicates do not hold");
-                        return None;
+                        return Some(None);
                     }
                 }
 
-                Some(mth)
+                Some(Some(mth))
             })
             .collect()
     }