rustup for big refactor; kill most of validation

rust-toolchain

@@ -1 +1 @@
-nightly-2018-08-14
+nightly-2018-08-30

src/helpers.rs

@@ -1,128 +1,71 @@
-use mir;
-use rustc::ty::Ty;
-use rustc::ty::layout::{LayoutOf, Size};
+use rustc::ty::layout::Size;
 
-use super::{Scalar, ScalarExt, EvalResult, EvalContext, ValTy};
-use rustc_mir::interpret::sign_extend;
+use super::{Scalar, ScalarMaybeUndef, EvalResult};
 
-pub trait EvalContextExt<'tcx> {
-    fn wrapping_pointer_offset(
-        &self,
-        ptr: Scalar,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> EvalResult<'tcx, Scalar>;
-
-    fn pointer_offset(
-        &self,
-        ptr: Scalar,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> EvalResult<'tcx, Scalar>;
-
-    fn value_to_isize(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, i64>;
+pub trait ScalarExt {
+    fn null(size: Size) -> Self;
+    fn from_i32(i: i32) -> Self;
+    fn from_uint(i: impl Into<u128>, ptr_size: Size) -> Self;
+    fn from_int(i: impl Into<i128>, ptr_size: Size) -> Self;
+    fn from_f32(f: f32) -> Self;
+    fn from_f64(f: f64) -> Self;
+    fn is_null(self) -> bool;
+}
 
-    fn value_to_usize(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, u64>;
+pub trait FalibleScalarExt {
+    /// HACK: this function just extracts all bits if `defined != 0`
+    /// Mainly used for args of C-functions and we should totally correctly fetch the size
+    /// of their arguments
+    fn to_bytes(self) -> EvalResult<'static, u128>;
+}
 
-    fn value_to_i32(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, i32>;
+impl ScalarExt for Scalar {
+    fn null(size: Size) -> Self {
+        Scalar::Bits { bits: 0, size: size.bytes() as u8 }
+    }
 
-    fn value_to_u8(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, u8>;
-}
+    fn from_i32(i: i32) -> Self {
+        Scalar::Bits { bits: i as u32 as u128, size: 4 }
+    }
 
-impl<'a, 'mir, 'tcx> EvalContextExt<'tcx> for EvalContext<'a, 'mir, 'tcx, super::Evaluator<'tcx>> {
-    fn wrapping_pointer_offset(
-        &self,
-        ptr: Scalar,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> EvalResult<'tcx, Scalar> {
-        // FIXME: assuming here that type size is < i64::max_value()
-        let pointee_size = self.layout_of(pointee_ty)?.size.bytes() as i64;
-        let offset = offset.overflowing_mul(pointee_size).0;
-        Ok(ptr.ptr_wrapping_signed_offset(offset, self))
+    fn from_uint(i: impl Into<u128>, size: Size) -> Self {
+        Scalar::Bits { bits: i.into(), size: size.bytes() as u8 }
     }
 
-    fn pointer_offset(
-        &self,
-        ptr: Scalar,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> EvalResult<'tcx, Scalar> {
-        // This function raises an error if the offset moves the pointer outside of its allocation.  We consider
-        // ZSTs their own huge allocation that doesn't overlap with anything (and nothing moves in there because the size is 0).
-        // We also consider the NULL pointer its own separate allocation, and all the remaining integers pointers their own
-        // allocation.
+    fn from_int(i: impl Into<i128>, size: Size) -> Self {
+        Scalar::Bits { bits: i.into() as u128, size: size.bytes() as u8 }
+    }
 
-        if ptr.is_null() {
-            // NULL pointers must only be offset by 0
-            return if offset == 0 {
-                Ok(ptr)
-            } else {
-                err!(InvalidNullPointerUsage)
-            };
-        }
-        // FIXME: assuming here that type size is < i64::max_value()
-        let pointee_size = self.layout_of(pointee_ty)?.size.bytes() as i64;
-         if let Some(offset) = offset.checked_mul(pointee_size) {
-            let ptr = ptr.ptr_signed_offset(offset, self)?;
-            // Do not do bounds-checking for integers; they can never alias a normal pointer anyway.
-            if let Scalar::Ptr(ptr) = ptr {
-                self.memory.check_bounds(ptr, false)?;
-            } else if ptr.is_null() {
-                // We moved *to* a NULL pointer.  That seems wrong, LLVM considers the NULL pointer its own small allocation.  Reject this, for now.
-                return err!(InvalidNullPointerUsage);
-            }
-            Ok(ptr)
-        } else {
-            err!(Overflow(mir::BinOp::Mul))
-        }
+    fn from_f32(f: f32) -> Self {
+        Scalar::Bits { bits: f.to_bits() as u128, size: 4 }
     }
 
-    fn value_to_isize(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, i64> {
-        assert_eq!(value.ty, self.tcx.types.isize);
-        let raw = self.value_to_scalar(value)?.to_bits(self.memory.pointer_size())?;
-        let raw = sign_extend(raw, self.layout_of(self.tcx.types.isize).unwrap());
-        Ok(raw as i64)
+    fn from_f64(f: f64) -> Self {
+        Scalar::Bits { bits: f.to_bits() as u128, size: 8 }
     }
 
-    fn value_to_usize(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, u64> {
-        assert_eq!(value.ty, self.tcx.types.usize);
-        self.value_to_scalar(value)?.to_bits(self.memory.pointer_size()).map(|v| v as u64)
+    fn is_null(self) -> bool {
+        match self {
+            Scalar::Bits { bits, .. } => bits == 0,
+            Scalar::Ptr(_) => false
+        }
     }
+}
 
-    fn value_to_i32(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, i32> {
-        assert_eq!(value.ty, self.tcx.types.i32);
-        let raw = self.value_to_scalar(value)?.to_bits(Size::from_bits(32))?;
-        let raw = sign_extend(raw, self.layout_of(self.tcx.types.i32).unwrap());
-        Ok(raw as i32)
+impl FalibleScalarExt for Scalar {
+    fn to_bytes(self) -> EvalResult<'static, u128> {
+        match self {
+            Scalar::Bits { bits, size } => {
+                assert_ne!(size, 0);
+                Ok(bits)
+            },
+            Scalar::Ptr(_) => err!(ReadPointerAsBytes),
+        }
     }
+}
 
-    fn value_to_u8(
-        &self,
-        value: ValTy<'tcx>,
-    ) -> EvalResult<'tcx, u8> {
-        assert_eq!(value.ty, self.tcx.types.u8);
-        self.value_to_scalar(value)?.to_bits(Size::from_bits(8)).map(|v| v as u8)
+impl FalibleScalarExt for ScalarMaybeUndef {
+    fn to_bytes(self) -> EvalResult<'static, u128> {
+        self.not_undef()?.to_bytes()
     }
 }