fix diagnostics printing when triggered during TLS dtor scheduling

[rust.git] / src / operator.rs

diff --git a/src/operator.rs b/src/operator.rs
index 0c83b5bed93b731fc0098d7708c5f65d0b2b87c3..5b86b9a76f6b48125906a9fdbd5fac091b9c9008 100644 (file)
--- a/src/operator.rs
+++ b/src/operator.rs
@@ -1,7 +1,6 @@
-use std::convert::TryFrom;
+use log::trace;
 
-use rustc::ty::{Ty, layout::{Size, Align, LayoutOf}};
-use rustc::mir;
+use rustc_middle::{mir, ty::Ty};
 
 use crate::*;
 
@@ -13,18 +12,7 @@ fn binary_ptr_op(
         right: ImmTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, (Scalar<Tag>, bool, Ty<'tcx>)>;
 
-    fn ptr_eq(
-        &self,
-        left: Scalar<Tag>,
-        right: Scalar<Tag>,
-    ) -> InterpResult<'tcx, bool>;
-
-    fn pointer_offset_inbounds(
-        &self,
-        ptr: Scalar<Tag>,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> InterpResult<'tcx, Scalar<Tag>>;
+    fn ptr_eq(&self, left: Scalar<Tag>, right: Scalar<Tag>) -> InterpResult<'tcx, bool>;
 }
 
 impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
@@ -34,19 +22,22 @@ fn binary_ptr_op(
         left: ImmTy<'tcx, Tag>,
         right: ImmTy<'tcx, Tag>,
     ) -> InterpResult<'tcx, (Scalar<Tag>, bool, Ty<'tcx>)> {
-        use rustc::mir::BinOp::*;
+        use rustc_middle::mir::BinOp::*;
 
         trace!("ptr_op: {:?} {:?} {:?}", *left, bin_op, *right);
 
         Ok(match bin_op {
             Eq | Ne => {
                 // This supports fat pointers.
+                #[rustfmt::skip]
                 let eq = match (*left, *right) {
-                    (Immediate::Scalar(left), Immediate::Scalar(right)) =>
-                        self.ptr_eq(left.not_undef()?, right.not_undef()?)?,
-                    (Immediate::ScalarPair(left1, left2), Immediate::ScalarPair(right1, right2)) =>
-                        self.ptr_eq(left1.not_undef()?, right1.not_undef()?)? &&
-                        self.ptr_eq(left2.not_undef()?, right2.not_undef()?)?,
+                    (Immediate::Scalar(left), Immediate::Scalar(right)) => {
+                        self.ptr_eq(left.check_init()?, right.check_init()?)?
+                    }
+                    (Immediate::ScalarPair(left1, left2), Immediate::ScalarPair(right1, right2)) => {
+                        self.ptr_eq(left1.check_init()?, right1.check_init()?)?
+                            && self.ptr_eq(left2.check_init()?, right2.check_init()?)?
+                    }
                     _ => bug!("Type system should not allow comparing Scalar with ScalarPair"),
                 };
                 (Scalar::from_bool(if bin_op == Eq { eq } else { !eq }), false, self.tcx.types.bool)
@@ -68,27 +59,21 @@ fn binary_ptr_op(
             }
 
             Offset => {
-                let pointee_ty = left.layout.ty
-                    .builtin_deref(true)
-                    .expect("Offset called on non-ptr type")
-                    .ty;
-                let ptr = self.pointer_offset_inbounds(
+                let pointee_ty =
+                    left.layout.ty.builtin_deref(true).expect("Offset called on non-ptr type").ty;
+                let ptr = self.ptr_offset_inbounds(
                     left.to_scalar()?,
                     pointee_ty,
-                    right.to_scalar()?.to_isize(self)?,
+                    right.to_scalar()?.to_machine_isize(self)?,
                 )?;
                 (ptr, false, left.layout.ty)
             }
 
-            _ => bug!("Invalid operator on pointers: {:?}", bin_op)
+            _ => bug!("Invalid operator on pointers: {:?}", bin_op),
         })
     }
 
-    fn ptr_eq(
-        &self,
-        left: Scalar<Tag>,
-        right: Scalar<Tag>,
-    ) -> InterpResult<'tcx, bool> {
+    fn ptr_eq(&self, left: Scalar<Tag>, right: Scalar<Tag>) -> InterpResult<'tcx, bool> {
         let size = self.pointer_size();
         // Just compare the integers.
         // TODO: Do we really want to *always* do that, even when comparing two live in-bounds pointers?
@@ -96,30 +81,4 @@ fn ptr_eq(
         let right = self.force_bits(right, size)?;
         Ok(left == right)
     }
-
-    /// Raises an error if the offset moves the pointer outside of its allocation.
-    /// For integers, we consider each of them their own tiny allocation of size 0,
-    /// so offset-by-0 is okay for them -- except for NULL, which we rule out entirely.
-    fn pointer_offset_inbounds(
-        &self,
-        ptr: Scalar<Tag>,
-        pointee_ty: Ty<'tcx>,
-        offset: i64,
-    ) -> InterpResult<'tcx, Scalar<Tag>> {
-        let pointee_size = i64::try_from(self.layout_of(pointee_ty)?.size.bytes()).unwrap();
-        let offset = offset
-            .checked_mul(pointee_size)
-            .ok_or_else(|| err_panic!(Overflow(mir::BinOp::Mul)))?;
-        // We do this forst, to rule out overflows.
-        let offset_ptr = ptr.ptr_signed_offset(offset, self)?;
-        // What we need to check is that starting at `ptr`,
-        // we could do an access of size `offset`. Alignment does not matter.
-        self.memory.check_ptr_access(
-            ptr,
-            Size::from_bytes(u64::try_from(offset).unwrap()),
-            Align::from_bytes(1).unwrap(),
-        )?;
-        // That's it!
-        Ok(offset_ptr)
-    }
 }