Remove pointer arithmetic intrinsics

These are now implemented in rustc's mir interpreter

Signed-off-by: Joe Richey <[email protected]>

Author: josephlr

src/operator.rs

@@ -1,9 +1,6 @@
-use std::convert::TryFrom;
-
 use log::trace;
 
 use rustc_middle::{mir, ty::Ty};
-use rustc_target::abi::{LayoutOf, Size};
 
 use crate::*;
 
@@ -16,13 +13,6 @@ pub trait EvalContextExt<'tcx> {
     ) -> 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>>;
 }
 
 impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
@@ -71,7 +61,7 @@ impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
             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 ptr = self.ptr_offset_inbounds(
                     left.to_scalar()?,
                     pointee_ty,
                     right.to_scalar()?.to_machine_isize(self)?,
@@ -91,38 +81,4 @@ impl<'mir, 'tcx> EvalContextExt<'tcx> for super::MiriEvalContext<'mir, 'tcx> {
         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_ub_format!("overflow during offset comutation for inbounds pointer arithmetic")
-        })?;
-        // We do this first, to rule out overflows.
-        let offset_ptr = ptr.ptr_signed_offset(offset, self)?;
-        // What we need to check is that starting at `min(ptr, offset_ptr)`,
-        // we could do an access of size `abs(offset)`. Alignment does not matter.
-        let (min_ptr, abs_offset) = if offset >= 0 {
-            (ptr, u64::try_from(offset).unwrap())
-        } else {
-            // Negative offset.
-            // If the negation overflows, the result will be negative so the try_from will fail.
-            (offset_ptr, u64::try_from(-offset).unwrap())
-        };
-        self.memory.check_ptr_access_align(
-            min_ptr,
-            Size::from_bytes(abs_offset),
-            None,
-            CheckInAllocMsg::InboundsTest,
-        )?;
-        // That's it!
-        Ok(offset_ptr)
-    }
 }

src/shims/intrinsics.rs

@@ -99,26 +99,6 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                     .write_bytes(ptr, iter::repeat(val_byte).take(byte_count.bytes() as usize))?;
             }
 
-            // Pointer arithmetic
-            "arith_offset" => {
-                let &[ptr, offset] = check_arg_count(args)?;
-                let ptr = this.read_scalar(ptr)?.not_undef()?;
-                let offset = this.read_scalar(offset)?.to_machine_isize(this)?;
-
-                let pointee_ty = substs.type_at(0);
-                let pointee_size = i64::try_from(this.layout_of(pointee_ty)?.size.bytes()).unwrap();
-                let offset = offset.overflowing_mul(pointee_size).0;
-                let result_ptr = ptr.ptr_wrapping_signed_offset(offset, this);
-                this.write_scalar(result_ptr, dest)?;
-            }
-            "offset" => {
-                let &[ptr, offset] = check_arg_count(args)?;
-                let ptr = this.read_scalar(ptr)?.not_undef()?;
-                let offset = this.read_scalar(offset)?.to_machine_isize(this)?;
-                let result_ptr = this.pointer_offset_inbounds(ptr, substs.type_at(0), offset)?;
-                this.write_scalar(result_ptr, dest)?;
-            }
-
             // Floating-point operations
             #[rustfmt::skip]
             | "sinf32"