miri: track the Align instead of packedness in PtrAndAlign.

Author: eddyb

src/librustc/mir/interpret/value.rs

@@ -1,6 +1,6 @@
 #![allow(unknown_lints)]
 
-use ty::layout::HasDataLayout;
+use ty::layout::{Align, HasDataLayout};
 
 use super::{EvalResult, MemoryPointer, PointerArithmetic};
 use syntax::ast::FloatTy;
@@ -9,8 +9,7 @@ use rustc_const_math::ConstFloat;
 #[derive(Copy, Clone, Debug)]
 pub struct PtrAndAlign {
     pub ptr: Pointer,
-    /// Remember whether this place is *supposed* to be aligned.
-    pub aligned: bool,
+    pub align: Align,
 }
 
 impl PtrAndAlign {
@@ -20,7 +19,7 @@ impl PtrAndAlign {
     pub fn offset<'tcx, C: HasDataLayout>(self, i: u64, cx: C) -> EvalResult<'tcx, Self> {
         Ok(PtrAndAlign {
             ptr: self.ptr.offset(i, cx)?,
-            aligned: self.aligned,
+            align: self.align,
         })
     }
 }
@@ -182,13 +181,6 @@ pub enum PrimValKind {
     Char,
 }
 
-impl<'a, 'tcx: 'a> Value {
-    #[inline]
-    pub fn by_ref(ptr: Pointer) -> Self {
-        Value::ByRef(PtrAndAlign { ptr, aligned: true })
-    }
-}
-
 impl<'tcx> PrimVal {
     pub fn from_u128(n: u128) -> Self {
         PrimVal::Bytes(n)

src/librustc_mir/interpret/const_eval.rs

@@ -77,7 +77,7 @@ pub fn eval_body<'a, 'tcx>(
             instance,
             mir.span,
             mir,
-            Place::from_ptr(ptr),
+            Place::from_ptr(ptr, layout.align),
             cleanup.clone(),
         )?;
 
@@ -357,10 +357,11 @@ pub fn const_eval_provider<'a, 'tcx>(
             (_, Err(err)) => Err(err),
             (Ok((miri_val, miri_ty)), Ok(ctfe)) => {
                 let mut ecx = mk_eval_cx(tcx, instance, key.param_env).unwrap();
-                check_ctfe_against_miri(&mut ecx, PtrAndAlign {
+                let miri_ptr = PtrAndAlign {
                     ptr: miri_val,
-                    aligned: true
-                }, miri_ty, ctfe.val);
+                    align: ecx.layout_of(miri_ty).unwrap().align
+                };
+                check_ctfe_against_miri(&mut ecx, miri_ptr, miri_ty, ctfe.val);
                 Ok(ctfe)
             }
         }
@@ -380,7 +381,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
     use rustc::ty::TypeVariants::*;
     match miri_ty.sty {
         TyInt(int_ty) => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let prim = get_prim(ecx, value);
@@ -391,7 +392,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
             assert_eq!(c, ctfe, "miri evaluated to {:?}, but ctfe yielded {:?}", c, ctfe);
         },
         TyUint(uint_ty) => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let prim = get_prim(ecx, value);
@@ -402,15 +403,15 @@ fn check_ctfe_against_miri<'a, 'tcx>(
             assert_eq!(c, ctfe, "miri evaluated to {:?}, but ctfe yielded {:?}", c, ctfe);
         },
         TyFloat(ty) => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let prim = get_prim(ecx, value);
             let f = ConstVal::Float(ConstFloat { bits: prim, ty });
             assert_eq!(f, ctfe, "miri evaluated to {:?}, but ctfe yielded {:?}", f, ctfe);
         },
         TyBool => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let bits = get_prim(ecx, value);
@@ -421,7 +422,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
             assert_eq!(b, ctfe, "miri evaluated to {:?}, but ctfe yielded {:?}", b, ctfe);
         },
         TyChar => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let bits = get_prim(ecx, value);
@@ -435,7 +436,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
             }
         },
         TyStr => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             if let Ok(Some(Value::ByValPair(PrimVal::Ptr(ptr), PrimVal::Bytes(len)))) = value {
@@ -522,8 +523,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
                     Field::new(field),
                     layout,
                 ).unwrap();
-                let ptr = place.to_ptr_extra_aligned().0;
-                check_ctfe_against_miri(ecx, ptr, elem.ty, elem.val);
+                check_ctfe_against_miri(ecx, place.to_ptr_align(), elem.ty, elem.val);
             }
         },
         TySlice(_) => bug!("miri produced a slice?"),
@@ -543,7 +543,7 @@ fn check_ctfe_against_miri<'a, 'tcx>(
         // should be fine
         TyFnDef(..) => {}
         TyFnPtr(_) => {
-            let value = ecx.read_maybe_aligned(miri_val.aligned, |ectx| {
+            let value = ecx.read_with_align(miri_val.align, |ectx| {
                 ectx.try_read_value(miri_val.ptr, miri_ty)
             });
             let ptr = match value {