diff --git a/src/lvalue.rs b/src/lvalue.rs
index b41a4629301e08b7c91146797a95b29de62ffb94..045f4f715b63349da010d9ccd797376bf419bed7 100644
--- a/src/lvalue.rs
+++ b/src/lvalue.rs
@@ -5,7 +5,7 @@ use rustc_data_structures::indexed_vec::Idx;
 
 use error::{EvalError, EvalResult};
 use eval_context::{EvalContext};
-use memory::{Pointer, PointerOffset};
+use memory::{Pointer};
 use value::{PrimVal, PrimValKind, Value};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -363,14 +363,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         PrimVal::Bytes(elem_size as u128),
                         PrimValKind::U64);
 
-                    let base_offset_primval = match p.offset {
-                        PointerOffset::Concrete(n) => PrimVal::Bytes(n as u128),
-                        PointerOffset::Abstract(sbytes) => PrimVal::Abstract(sbytes),
-                    };
-
                     match self.memory.constraints.add_binop_constraint(
                         mir::BinOp::Add,
-                        base_offset_primval,
+                        p.offset.as_primval(),
                         byte_index,
                         PrimValKind::U64) {
                         PrimVal::Abstract(sbytes) => {
diff --git a/src/memory.rs b/src/memory.rs
index 7c6ba67e061cf47887142468d8cfe8c3aece3a41..83a637a0aee7cd407e60625bf97bdd04a311c35c 100644
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -78,6 +78,15 @@ pub enum PointerOffset {
     Abstract([SByte; 8]),
 }
 
+impl PointerOffset {
+    pub fn as_primval(&self) -> PrimVal {
+        match *self {
+            PointerOffset::Concrete(n) => PrimVal::Bytes(n as u128),
+            PointerOffset::Abstract(sbytes) => PrimVal::Abstract(sbytes),
+        }
+    }
+}
+
 impl Pointer {
     pub fn new(alloc_id: AllocId, offset: u64) -> Self {
         Pointer { alloc_id, offset: PointerOffset::Concrete(offset), }
diff --git a/src/operator.rs b/src/operator.rs
index 771e875a4bd4257f5d105dd019f543b5cd22b252..3ccbffc24debd79b96f25e84d301068eeb5f0aba 100644
--- a/src/operator.rs
+++ b/src/operator.rs
@@ -420,17 +420,6 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     ) -> EvalResult<'tcx, (PrimVal, bool)> {
         use rustc::mir::BinOp::*;
         use value::PrimValKind::*;
-
-        let left_offset_primval = match left.offset {
-            PointerOffset::Concrete(n) => PrimVal::Bytes(n as u128),
-            PointerOffset::Abstract(sbytes) => PrimVal::Abstract(sbytes),
-        };
-
-        let right_offset_primval = match right.offset {
-            PointerOffset::Concrete(n) => PrimVal::Bytes(n as u128),
-            PointerOffset::Abstract(sbytes) => PrimVal::Abstract(sbytes),
-        };
-
         if left.alloc_id != right.alloc_id {
             if let Eq = bin_op {
                 unimplemented!()
@@ -439,7 +428,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
             }
         } else {
             let result = self.memory.constraints.add_binop_constraint(
-                bin_op, left_offset_primval, right_offset_primval, U64);
+                bin_op, left.offset.as_primval(), right.offset.as_primval(), U64);
             Ok((result, false))
         }
     }
diff --git a/src/terminator/intrinsic.rs b/src/terminator/intrinsic.rs
index 2a575e1838f7e3fd6e70ef01765f69f7a2ee4d4f..79b6b96b1f14f946999352b75e9b3eac08fd7fa0 100644
--- a/src/terminator/intrinsic.rs
+++ b/src/terminator/intrinsic.rs
@@ -7,7 +7,7 @@ use rustc::ty::{self, Ty};
 use error::{EvalError, EvalResult};
 use eval_context::{EvalContext, ValTy};
 use lvalue::{Lvalue, LvalueExtra};
-use memory::{Pointer, PointerOffset};
+use memory::{Pointer};
 use value::{PrimVal, PrimValKind, Value};
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
@@ -316,10 +316,6 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     let result_ptr = self.pointer_offset(ptr, substs.type_at(0), offset)?;
                     self.write_primval(dest, result_ptr, dest_ty)?;
                 } else {
-                    let ptr_offset_primval = match ptr.to_ptr()?.offset {
-                        PointerOffset::Concrete(n) => PrimVal::Bytes(n as u128),
-                        PointerOffset::Abstract(sbytes) => PrimVal::Abstract(sbytes),
-                    };
                     // need to account for the size of the type.
                     let size =
                         self.type_size(substs.type_at(0))?.expect(
@@ -332,7 +328,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         PrimValKind::U64);
                     let new_offset = self.memory.constraints.add_binop_constraint(
                         mir::BinOp::Add,
-                        ptr_offset_primval,
+                        ptr.to_ptr()?.offset.as_primval(),
                         byte_offset,
                         PrimValKind::U64);
                     if let PrimVal::Abstract(sbytes) = new_offset {