2 files changed, 20 insertions, 12 deletions
diff --git a/src/librustc/mir/interpret/allocation.rs b/src/librustc/mir/interpret/allocation.rs
index 296c2e2dd6b..c612d6ad1bb 100644
--- a/src/librustc/mir/interpret/allocation.rs
+++ b/src/librustc/mir/interpret/allocation.rs
@@ -57,23 +57,14 @@ pub struct Allocation<Tag=(),Extra=()> {
 impl<'tcx, Tag, Extra> Allocation<Tag, Extra> {
     /// Check if the pointer is "in-bounds". Notice that a pointer pointing at the end
     /// of an allocation (i.e., at the first *inaccessible* location) *is* considered
-    /// in-bounds!  This follows C's/LLVM's rules.  `check` indicates whether we
-    /// additionally require the pointer to be pointing to a *live* (still allocated)
-    /// allocation.
+    /// in-bounds!  This follows C's/LLVM's rules.
     /// If you want to check bounds before doing a memory access, better use `check_bounds`.
     pub fn check_bounds_ptr(
         &self,
         ptr: Pointer<Tag>,
     ) -> EvalResult<'tcx> {
         let allocation_size = self.bytes.len() as u64;
-        if ptr.offset.bytes() > allocation_size {
-            return err!(PointerOutOfBounds {
-                ptr: ptr.erase_tag(),
-                check: InboundsCheck::Live,
-                allocation_size: Size::from_bytes(allocation_size),
-            });
-        }
-        Ok(())
+        ptr.check_in_alloc(Size::from_bytes(allocation_size), InboundsCheck::Live)
     }
 
     /// Check if the memory range beginning at `ptr` and of size `Size` is "in-bounds".
diff --git a/src/librustc/mir/interpret/pointer.rs b/src/librustc/mir/interpret/pointer.rs
index 969f2c0e837..a046825f088 100644
--- a/src/librustc/mir/interpret/pointer.rs
+++ b/src/librustc/mir/interpret/pointer.rs
@@ -2,7 +2,7 @@ use mir;
 use ty::layout::{self, HasDataLayout, Size};
 
 use super::{
-    AllocId, EvalResult,
+    AllocId, EvalResult, InboundsCheck,
 };
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -148,4 +148,21 @@ impl<'tcx, Tag> Pointer<Tag> {
     pub fn erase_tag(self) -> Pointer {
         Pointer { alloc_id: self.alloc_id, offset: self.offset, tag: () }
     }
+
+    #[inline(always)]
+    pub fn check_in_alloc(
+        self,
+        allocation_size: Size,
+        check: InboundsCheck,
+    ) -> EvalResult<'tcx, ()> {
+        if self.offset > allocation_size {
+            err!(PointerOutOfBounds {
+                ptr: self.erase_tag(),
+                check,
+                allocation_size,
+            })
+        } else {
+            Ok(())
+        }
+    }
 }