diff --git a/src/cast.rs b/src/cast.rs
index ef147fcf8713e968491c4aa9702ebda6b379ff72..e32f6bd6558ebc38c1ee603c62573b792197406c 100644
--- a/src/cast.rs
+++ b/src/cast.rs
@@ -4,7 +4,7 @@ use syntax::ast::{IntTy, UintTy};
 use rustc_const_math::ConstFloat;
 use error::{EvalResult, EvalError};
 use eval_context::EvalContext;
-use memory::{Pointer, SByte};
+use memory::{MemoryPointer, SByte};
 use value::PrimVal;
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
@@ -118,7 +118,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         }
     }
 
-    fn cast_from_ptr(&self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
+    fn cast_from_ptr(&self, ptr: MemoryPointer, ty: Ty<'tcx>) -> EvalResult<'tcx, PrimVal> {
         use rustc::ty::TypeVariants::*;
         match ty.sty {
             // Casting to a reference or fn pointer is not permitted by rustc, no need to support it here.
diff --git a/src/error.rs b/src/error.rs
index 053a5c8beb62c1cfd9fcf492e443c9421c64be51..736c21ac43552e7336098b7b950304f519946065 100644
--- a/src/error.rs
+++ b/src/error.rs
@@ -2,7 +2,7 @@ use std::error::Error;
 use std::fmt;
 use rustc::mir;
 use rustc::ty::{FnSig, Ty, layout};
-use memory::{Pointer, PointerOffset};
+use memory::{MemoryPointer, PointerOffset};
 use rustc_const_math::ConstMathErr;
 use syntax::codemap::Span;
 
@@ -10,14 +10,14 @@ use syntax::codemap::Span;
 pub enum EvalError<'tcx> {
     FunctionPointerTyMismatch(FnSig<'tcx>, FnSig<'tcx>),
     NoMirFor(String),
-    UnterminatedCString(Pointer),
+    UnterminatedCString(MemoryPointer),
     DanglingPointerDeref,
     InvalidMemoryAccess,
     InvalidFunctionPointer,
     InvalidBool,
     InvalidDiscriminant,
     PointerOutOfBounds {
-        ptr: Pointer,
+        ptr: MemoryPointer,
         access: bool,
         allocation_size: u64,
     },
@@ -198,14 +198,14 @@ impl<'tcx> fmt::Display for EvalError<'tcx> {
 pub enum StaticEvalError {
     FunctionPointerTyMismatch,
     NoMirFor(String),
-    UnterminatedCString(Pointer),
+    UnterminatedCString(MemoryPointer),
     DanglingPointerDeref,
     InvalidMemoryAccess,
     InvalidFunctionPointer,
     InvalidBool,
     InvalidDiscriminant,
     PointerOutOfBounds {
-        ptr: Pointer,
+        ptr: MemoryPointer,
         access: bool,
         allocation_size: u64,
     },
diff --git a/src/eval_context.rs b/src/eval_context.rs
index d470d2880c7e404836ede567ab4a0593b142ac8b..baa3ec7dc42beed73383d73b80aac8756e59b349 100644
--- a/src/eval_context.rs
+++ b/src/eval_context.rs
@@ -14,7 +14,7 @@ use syntax::ast;
 
 use error::{EvalError, EvalResult};
 use lvalue::{Global, GlobalId, Lvalue, LvalueExtra};
-use memory::{Memory, Pointer};
+use memory::{Memory, MemoryPointer};
 use value::{PrimVal, PrimValKind, Value};
 
 
@@ -41,7 +41,7 @@ pub struct EvalContext<'a, 'tcx: 'a> {
 
     /// Environment variables set by `setenv`
     /// Miri does not expose env vars from the host to the emulated program
-    pub(crate) env_vars: HashMap<Vec<u8>, Pointer>,
+    pub(crate) env_vars: HashMap<Vec<u8>, MemoryPointer>,
 }
 
 impl <'a, 'tcx: 'a> Clone for EvalContext<'a, 'tcx> {
@@ -230,7 +230,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         }
     }
 
-    pub fn alloc_ptr(&mut self, ty: Ty<'tcx>) -> EvalResult<'tcx, Pointer> {
+    pub fn alloc_ptr(&mut self, ty: Ty<'tcx>) -> EvalResult<'tcx, MemoryPointer> {
         let substs = self.substs();
         self.alloc_ptr_with_substs(ty, substs)
     }
@@ -239,7 +239,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         &mut self,
         ty: Ty<'tcx>,
         substs: &'tcx Substs<'tcx>
-    ) -> EvalResult<'tcx, Pointer> {
+    ) -> EvalResult<'tcx, MemoryPointer> {
         let size = self.type_size_with_substs(ty, substs)?.expect("cannot alloc memory for unsized type");
         let align = self.type_align_with_substs(ty, substs)?;
         self.memory.allocate(size, align)
@@ -1087,7 +1087,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         &mut self,
         a: PrimVal,
         b: PrimVal,
-        ptr: Pointer,
+        ptr: MemoryPointer,
         ty: Ty<'tcx>
     ) -> EvalResult<'tcx> {
         let mut layout = self.type_layout(ty)?;
@@ -1195,7 +1195,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         }
     }
 
-    pub(super) fn read_value(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
+    pub(super) fn read_value(&mut self, ptr: MemoryPointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
         if let Some(val) = self.try_read_value(ptr, ty)? {
             Ok(val)
         } else {
@@ -1203,7 +1203,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         }
     }
 
-    pub(crate) fn read_ptr(&mut self, ptr: Pointer, pointee_ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
+    pub(crate) fn read_ptr(&mut self, ptr: MemoryPointer, pointee_ty: Ty<'tcx>) -> EvalResult<'tcx, Value> {
         let p = self.memory.read_ptr(ptr)?;
         if self.type_is_sized(pointee_ty) {
             Ok(Value::ByVal(p))
@@ -1227,7 +1227,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         }
     }
 
-    fn try_read_value(&mut self, ptr: Pointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Option<Value>> {
+    fn try_read_value(&mut self, ptr: MemoryPointer, ty: Ty<'tcx>) -> EvalResult<'tcx, Option<Value>> {
         use syntax::ast::FloatTy;
 
         if !ptr.has_concrete_offset() {
diff --git a/src/lib.rs b/src/lib.rs
index 67c0d3e0bf905ef5180d4b38ece6ca148d067c7c..08cd73f744f127416592832b9ede7e6301acf745 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -61,7 +61,7 @@ pub use lvalue::{
 pub use memory::{
     AllocId,
     Memory,
-    Pointer,
+    MemoryPointer,
 };
 
 pub use value::{
diff --git a/src/lvalue.rs b/src/lvalue.rs
index 27bb44112518d9168c9134c90855ef6b17383d83..2ef57c70a32c3862ce56794faaa9502f08070bce 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};
+use memory::{MemoryPointer};
 use value::{PrimVal, PrimValKind, Value};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
@@ -31,7 +31,7 @@ pub enum Lvalue<'tcx> {
 pub enum LvalueExtra {
     None,
     Length(PrimVal),
-    Vtable(Pointer),
+    Vtable(MemoryPointer),
     DowncastVariant(usize),
 }
 
@@ -68,7 +68,7 @@ impl<'tcx> Lvalue<'tcx> {
         Lvalue::Ptr { ptr, extra: LvalueExtra::None }
     }
 
-    pub fn from_ptr(ptr: Pointer) -> Self {
+    pub fn from_ptr(ptr: MemoryPointer) -> Self {
         Self::from_primval_ptr(PrimVal::Ptr(ptr))
     }
 
@@ -80,7 +80,7 @@ impl<'tcx> Lvalue<'tcx> {
         }
     }
 
-    pub(super) fn to_ptr(self) -> EvalResult<'tcx, Pointer> {
+    pub(super) fn to_ptr(self) -> EvalResult<'tcx, MemoryPointer> {
         let (ptr, extra) = self.to_ptr_and_extra();
         assert_eq!(extra, LvalueExtra::None);
         ptr.to_ptr()
@@ -370,7 +370,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                     p.offset.as_primval(),
                     byte_index,
                     PrimValKind::U64);
-                PrimVal::Ptr(Pointer::with_primval_offset(p.alloc_id, offset))
+                PrimVal::Ptr(MemoryPointer::with_primval_offset(p.alloc_id, offset))
             };
 
             Ok(Lvalue::Ptr {
diff --git a/src/memory.rs b/src/memory.rs
index 124275d860318d76c110e5c95ee93166f9ca2e45..3f3fc82e48ac1fc94afced8a3c7cc583cb816a35 100644
--- a/src/memory.rs
+++ b/src/memory.rs
@@ -64,7 +64,7 @@ pub enum StaticKind {
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
-pub struct Pointer {
+pub struct MemoryPointer {
     pub alloc_id: AllocId,
     pub offset: PointerOffset,
 }
@@ -87,19 +87,19 @@ impl PointerOffset {
     }
 }
 
-impl Pointer {
+impl MemoryPointer {
     pub fn new(alloc_id: AllocId, offset: u64) -> Self {
-        Pointer { alloc_id, offset: PointerOffset::Concrete(offset), }
+        MemoryPointer { alloc_id, offset: PointerOffset::Concrete(offset), }
     }
 
     pub fn new_abstract(alloc_id: AllocId, offset: [SByte; 8]) -> Self {
-        Pointer { alloc_id, offset: PointerOffset::Abstract(offset), }
+        MemoryPointer { alloc_id, offset: PointerOffset::Abstract(offset), }
     }
 
     pub fn with_primval_offset(alloc_id: AllocId, offset: PrimVal) -> Self {
         match offset {
-            PrimVal::Abstract(sbytes) => Pointer::new_abstract(alloc_id, sbytes),
-            PrimVal::Bytes(b) => Pointer::new(alloc_id, b as u64),
+            PrimVal::Abstract(sbytes) => MemoryPointer::new_abstract(alloc_id, sbytes),
+            PrimVal::Bytes(b) => MemoryPointer::new(alloc_id, b as u64),
             PrimVal::Undef => panic!("tried to construct pointer with undefined offset"),
             PrimVal::Ptr(_) => panic!("tried to construct point with pointer offset"),
         }
@@ -115,7 +115,7 @@ impl Pointer {
     pub fn wrapping_signed_offset<'tcx>(self, i: i64, layout: &TargetDataLayout) -> Self {
         match self.offset {
             PointerOffset::Concrete(self_offset) => {
-                Pointer::new(self.alloc_id, value::wrapping_signed_offset(self_offset, i, layout))
+                MemoryPointer::new(self.alloc_id, value::wrapping_signed_offset(self_offset, i, layout))
             }
             _ => unimplemented!(),
         }
@@ -125,7 +125,7 @@ impl Pointer {
         match self.offset {
             PointerOffset::Concrete(self_offset) => {
                 let (res, over) = value::overflowing_signed_offset(self_offset, i, layout);
-                (Pointer::new(self.alloc_id, res), over)
+                (MemoryPointer::new(self.alloc_id, res), over)
             }
             _ => unimplemented!(),
         }
@@ -134,7 +134,7 @@ impl Pointer {
     pub fn signed_offset<'tcx>(self, i: i64, layout: &TargetDataLayout) -> EvalResult<'tcx, Self> {
         match self.offset {
             PointerOffset::Concrete(self_offset) => {
-                Ok(Pointer::new(self.alloc_id, value::signed_offset(self_offset, i, layout)?))
+                Ok(MemoryPointer::new(self.alloc_id, value::signed_offset(self_offset, i, layout)?))
             }
             _ => unimplemented!(),
         }
@@ -144,7 +144,7 @@ impl Pointer {
         match self.offset {
             PointerOffset::Concrete(self_offset) => {
                 let (res, over) = value::overflowing_offset(self_offset, i, layout);
-                (Pointer::new(self.alloc_id, res), over)
+                (MemoryPointer::new(self.alloc_id, res), over)
             }
             _ => unimplemented!(),
         }
@@ -153,13 +153,13 @@ impl Pointer {
     pub fn offset<'tcx>(self, i: u64, layout: &TargetDataLayout) -> EvalResult<'tcx, Self> {
         match self.offset {
             PointerOffset::Concrete(offset) => {
-                Ok(Pointer::new(self.alloc_id, value::offset(offset, i, layout)?))
+                Ok(MemoryPointer::new(self.alloc_id, value::offset(offset, i, layout)?))
             }
             _ => unimplemented!(),
         }
     }
 
-    pub fn to_value_with_vtable(self, vtable: Pointer) -> Value {
+    pub fn to_value_with_vtable(self, vtable: MemoryPointer) -> Value {
         Value::ByValPair(PrimVal::Ptr(self), PrimVal::Ptr(vtable))
     }
 }
@@ -245,21 +245,21 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         self.alloc_map.iter()
     }
 
-    pub fn create_fn_alloc(&mut self, instance: ty::Instance<'tcx>) -> Pointer {
+    pub fn create_fn_alloc(&mut self, instance: ty::Instance<'tcx>) -> MemoryPointer {
         if let Some(&alloc_id) = self.function_alloc_cache.get(&instance) {
-            return Pointer::new(alloc_id, 0);
+            return MemoryPointer::new(alloc_id, 0);
         }
         let id = self.next_id;
         debug!("creating fn ptr: {}", id);
         self.next_id.0 += 1;
         self.functions.insert(id, instance);
         self.function_alloc_cache.insert(instance, id);
-        Pointer::new(id, 0)
+        MemoryPointer::new(id, 0)
     }
 
-    pub fn allocate_cached(&mut self, bytes: &[u8]) -> EvalResult<'tcx, Pointer> {
+    pub fn allocate_cached(&mut self, bytes: &[u8]) -> EvalResult<'tcx, MemoryPointer> {
         if let Some(&alloc_id) = self.literal_alloc_cache.get(bytes) {
-            return Ok(Pointer::new(alloc_id, 0));
+            return Ok(MemoryPointer::new(alloc_id, 0));
         }
 
         let ptr = self.allocate(bytes.len() as u64, 1)?;
@@ -269,7 +269,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(ptr)
     }
 
-    pub fn allocate(&mut self, size: u64, align: u64) -> EvalResult<'tcx, Pointer> {
+    pub fn allocate(&mut self, size: u64, align: u64) -> EvalResult<'tcx, MemoryPointer> {
         assert_ne!(align, 0);
         assert!(align.is_power_of_two());
 
@@ -292,12 +292,12 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         let id = self.next_id;
         self.next_id.0 += 1;
         self.alloc_map.insert(id, alloc);
-        Ok(Pointer::new(id, 0))
+        Ok(MemoryPointer::new(id, 0))
     }
 
     // TODO(solson): Track which allocations were returned from __rust_allocate and report an error
     // when reallocating/deallocating any others.
-    pub fn reallocate(&mut self, ptr: Pointer, new_size: u64, align: u64) -> EvalResult<'tcx, Pointer> {
+    pub fn reallocate(&mut self, ptr: MemoryPointer, new_size: u64, align: u64) -> EvalResult<'tcx, MemoryPointer> {
         assert!(align.is_power_of_two());
         let ptr_offset = match ptr.offset {
             PointerOffset::Concrete(offset) => offset,
@@ -331,11 +331,11 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             alloc.undef_mask.truncate(new_size);
         }
 
-        Ok(Pointer::new(ptr.alloc_id, 0))
+        Ok(MemoryPointer::new(ptr.alloc_id, 0))
     }
 
     // TODO(solson): See comment on `reallocate`.
-    pub fn deallocate(&mut self, ptr: Pointer) -> EvalResult<'tcx> {
+    pub fn deallocate(&mut self, ptr: MemoryPointer) -> EvalResult<'tcx> {
         let ptr_offset = match ptr.offset {
             PointerOffset::Concrete(offset) => offset,
             _ => unimplemented!(),
@@ -370,7 +370,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         self.layout.endian
     }
 
-    pub fn check_align(&self, ptr: Pointer, align: u64, len: u64) -> EvalResult<'tcx> {
+    pub fn check_align(&self, ptr: MemoryPointer, align: u64, len: u64) -> EvalResult<'tcx> {
         let ptr_offset = match ptr.offset {
             PointerOffset::Concrete(offset) => offset,
             _ => unimplemented!(),
@@ -413,7 +413,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         }
     }
 
-    pub(crate) fn check_bounds(&self, ptr: Pointer, access: bool) -> EvalResult<'tcx> {
+    pub(crate) fn check_bounds(&self, ptr: MemoryPointer, access: bool) -> EvalResult<'tcx> {
         let alloc = self.get(ptr.alloc_id)?;
         let allocation_size = alloc.bytes.len() as u64;
 
@@ -428,7 +428,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    pub(crate) fn mark_packed(&mut self, ptr: Pointer, len: u64) {
+    pub(crate) fn mark_packed(&mut self, ptr: MemoryPointer, len: u64) {
         let ptr_offset = match ptr.offset {
             PointerOffset::Concrete(offset) => offset,
             _ => unimplemented!(),
@@ -486,7 +486,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         }
     }
 
-    pub fn get_fn(&self, ptr: Pointer) -> EvalResult<'tcx, ty::Instance<'tcx>> {
+    pub fn get_fn(&self, ptr: MemoryPointer) -> EvalResult<'tcx, ty::Instance<'tcx>> {
         //if ptr.offset != 0 {
         //    return Err(EvalError::InvalidFunctionPointer);
         //}
@@ -591,7 +591,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
 
 /// Byte accessors
 impl<'a, 'tcx> Memory<'a, 'tcx> {
-    fn get_bytes_unchecked(&self, ptr: Pointer, size: u64, align: u64)
+    fn get_bytes_unchecked(&self, ptr: MemoryPointer, size: u64, align: u64)
                            -> EvalResult<'tcx, &[SByte]>
     {
         if size == 0 {
@@ -615,7 +615,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(&alloc.bytes[offset..offset + size as usize])
     }
 
-    fn get_bytes_unchecked_mut(&mut self, ptr: Pointer, size: u64, align: u64)
+    fn get_bytes_unchecked_mut(&mut self, ptr: MemoryPointer, size: u64, align: u64)
                                -> EvalResult<'tcx, &mut [SByte]>
     {
         if size == 0 {
@@ -637,7 +637,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(&mut alloc.bytes[ptr_offset..ptr_offset + size as usize])
     }
 
-    fn get_bytes(&self, ptr: Pointer, size: u64, align: u64)
+    fn get_bytes(&self, ptr: MemoryPointer, size: u64, align: u64)
                  -> EvalResult<'tcx, &[SByte]>
     {
         if size == 0 {
@@ -650,7 +650,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         self.get_bytes_unchecked(ptr, size, align)
     }
 
-    fn get_bytes_mut(&mut self, ptr: Pointer, size: u64, align: u64)
+    fn get_bytes_mut(&mut self, ptr: MemoryPointer, size: u64, align: u64)
                      -> EvalResult<'tcx, &mut [SByte]>
     {
         if size == 0 {
@@ -661,7 +661,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         self.get_bytes_unchecked_mut(ptr, size, align)
     }
 
-    pub fn write_fresh_abstract_bytes(&mut self, ptr: Pointer, size: u64)
+    pub fn write_fresh_abstract_bytes(&mut self, ptr: MemoryPointer, size: u64)
         -> EvalResult<'tcx>
     {
         let mut abytes = Vec::new();
@@ -781,7 +781,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    fn abstract_copy(&mut self, src: Pointer, dest: Pointer, size: u64, _align: u64)
+    fn abstract_copy(&mut self, src: MemoryPointer, dest: MemoryPointer, size: u64, _align: u64)
                      -> EvalResult<'tcx>
     {
         if src.alloc_id == dest.alloc_id {
@@ -830,7 +830,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(arr)
     }
 
-    pub fn read_c_str(&self, _ptr: Pointer) -> EvalResult<'tcx, &[u8]> {
+    pub fn read_c_str(&self, _ptr: MemoryPointer) -> EvalResult<'tcx, &[u8]> {
         unimplemented!()
         /*
         let alloc = self.get(ptr.alloc_id)?;
@@ -872,7 +872,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(PrimVal::Abstract(result_sbytes))
     }
 
-    pub fn write_bytes(&mut self, ptr: Pointer, src: &[u8]) -> EvalResult<'tcx> {
+    pub fn write_bytes(&mut self, ptr: MemoryPointer, src: &[u8]) -> EvalResult<'tcx> {
         let bytes = self.get_bytes_mut(ptr, src.len() as u64, 1)?;
         for idx in 0..bytes.len() {
             bytes[idx] = SByte::Concrete(src[idx]);
@@ -880,13 +880,13 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    pub fn write_repeat(&mut self, ptr: Pointer, val: u8, count: u64) -> EvalResult<'tcx> {
+    pub fn write_repeat(&mut self, ptr: MemoryPointer, val: u8, count: u64) -> EvalResult<'tcx> {
         let bytes = self.get_bytes_mut(ptr, count, 1)?;
         for b in bytes { *b = SByte::Concrete(val); }
         Ok(())
     }
 
-    pub fn read_primval(&self, ptr: Pointer, size: u64, signed: bool) -> EvalResult<'tcx, PrimVal> {
+    pub fn read_primval(&self, ptr: MemoryPointer, size: u64, signed: bool) -> EvalResult<'tcx, PrimVal> {
         self.check_relocation_edges(ptr, size)?; // Make sure we don't read part of a pointer as a pointer
         let endianess = self.endianness();
         let bytes = self.get_bytes_unchecked(ptr, size, self.int_align(size)?)?;
@@ -911,7 +911,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             match ptr.offset {
                 PointerOffset::Concrete(off) => {
                     match alloc.relocations.get(&off) {
-                        Some(&alloc_id) => return Ok(PrimVal::Ptr(Pointer::new(alloc_id, bytes as u64))),
+                        Some(&alloc_id) => return Ok(PrimVal::Ptr(MemoryPointer::new(alloc_id, bytes as u64))),
                         None => {},
                     }
                 }
@@ -922,7 +922,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(PrimVal::Bytes(bytes))
     }
 
-    pub fn read_ptr(&self, ptr: Pointer) -> EvalResult<'tcx, PrimVal> {
+    pub fn read_ptr(&self, ptr: MemoryPointer) -> EvalResult<'tcx, PrimVal> {
         let size = self.pointer_size();
         if self.check_defined(ptr, size).is_err() {
             return Ok(PrimVal::Undef);
@@ -942,7 +942,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             let offset = offset as u64;
 
             match alloc.relocations.get(&ptr_offset) {
-                Some(&alloc_id) => Ok(PrimVal::Ptr(Pointer::new(alloc_id, offset))),
+                Some(&alloc_id) => Ok(PrimVal::Ptr(MemoryPointer::new(alloc_id, offset))),
                 None => Ok(PrimVal::Bytes(offset as u128)),
             }
         } else {
@@ -950,13 +950,13 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
             sbytes.copy_from_slice(self.get_bytes_unchecked(ptr, size, size)?);
 
             match alloc.relocations.get(&ptr_offset) {
-                Some(&alloc_id) => Ok(PrimVal::Ptr(Pointer::new_abstract(alloc_id, sbytes))),
+                Some(&alloc_id) => Ok(PrimVal::Ptr(MemoryPointer::new_abstract(alloc_id, sbytes))),
                 None => unimplemented!(),
             }
         }
     }
 
-    pub fn write_ptr(&mut self, dest: Pointer, ptr: Pointer) -> EvalResult<'tcx> {
+    pub fn write_ptr(&mut self, dest: MemoryPointer, ptr: MemoryPointer) -> EvalResult<'tcx> {
         match (ptr.offset, dest.offset) {
             (PointerOffset::Concrete(ptr_offset),
              PointerOffset::Concrete(dest_offset)) => {
@@ -1024,7 +1024,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
 
     fn write_primval_to_abstract_ptr(
         &mut self,
-        dest: Pointer,
+        dest: MemoryPointer,
         val: PrimVal,
         size: u64,
     ) -> EvalResult<'tcx> {
@@ -1075,7 +1075,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
                 let sbyte = self.constraints.add_array_element_constraint(
                     arr, PrimVal::Bytes(idx as u128));
 
-                let ptr = Pointer::new(dest.alloc_id, idx as u64);
+                let ptr = MemoryPointer::new(dest.alloc_id, idx as u64);
                 self.get_bytes_mut(ptr, 1, 1)?[0] = sbyte;
             }
 
@@ -1085,7 +1085,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         }
     }
 
-    pub fn read_bool(&self, ptr: Pointer) -> EvalResult<'tcx, PrimVal> {
+    pub fn read_bool(&self, ptr: MemoryPointer) -> EvalResult<'tcx, PrimVal> {
         let bytes = self.get_bytes(ptr, 1, self.layout.i1_align.abi())?;
         match bytes[0] {
             SByte::Concrete(0) => Ok(PrimVal::from_bool(false)),
@@ -1100,7 +1100,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
     }
 
     /*
-    pub fn write_bool(&mut self, ptr: Pointer, b: bool) -> EvalResult<'tcx> {
+    pub fn write_bool(&mut self, ptr: MemoryPointer, b: bool) -> EvalResult<'tcx> {
         let align = self.layout.i1_align.abi();
         self.get_bytes_mut(ptr, 1, align)
             .map(|bytes| bytes[0] = b as u8)
@@ -1117,12 +1117,12 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         }
     }
 
-    pub fn read_int(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx, i128> {
+    pub fn read_int(&self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx, i128> {
         let align = self.int_align(size)?;
         self.get_bytes(ptr, size, align).map(|b| read_target_int(self.endianness(), b).unwrap())
     }
 
-    pub fn write_int(&mut self, ptr: Pointer, n: i128, size: u64) -> EvalResult<'tcx> {
+    pub fn write_int(&mut self, ptr: MemoryPointer, n: i128, size: u64) -> EvalResult<'tcx> {
         let align = self.int_align(size)?;
         let endianness = self.endianness();
         let mut bytes = vec![0u8; size as usize];
@@ -1134,7 +1134,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    pub fn points_to_concrete(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx, bool> {
+    pub fn points_to_concrete(&self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx, bool> {
         let bytes = self.get_bytes_unchecked(ptr, size, 1)?;
         for &b in bytes {
             match b {
@@ -1146,12 +1146,12 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(true)
     }
 
-    pub fn read_uint(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx, u128> {
+    pub fn read_uint(&self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx, u128> {
         let align = self.int_align(size)?;
         self.get_bytes(ptr, size, align).map(|b| read_target_uint(self.endianness(), b).unwrap())
     }
 
-    pub fn write_uint(&mut self, ptr: Pointer, n: u128, size: u64) -> EvalResult<'tcx> {
+    pub fn write_uint(&mut self, ptr: MemoryPointer, n: u128, size: u64) -> EvalResult<'tcx> {
         let align = self.int_align(size)?;
         let endianness = self.endianness();
         let sb = self.get_bytes_mut(ptr, size, align)?;
@@ -1163,26 +1163,26 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    pub fn read_isize(&self, ptr: Pointer) -> EvalResult<'tcx, i64> {
+    pub fn read_isize(&self, ptr: MemoryPointer) -> EvalResult<'tcx, i64> {
         self.read_int(ptr, self.pointer_size()).map(|i| i as i64)
     }
 
-    pub fn write_isize(&mut self, ptr: Pointer, n: i64) -> EvalResult<'tcx> {
+    pub fn write_isize(&mut self, ptr: MemoryPointer, n: i64) -> EvalResult<'tcx> {
         let size = self.pointer_size();
         self.write_int(ptr, n as i128, size)
     }
 
-    pub fn read_usize(&self, ptr: Pointer) -> EvalResult<'tcx, u64> {
+    pub fn read_usize(&self, ptr: MemoryPointer) -> EvalResult<'tcx, u64> {
         self.read_uint(ptr, self.pointer_size()).map(|i| i as u64)
     }
 
-    pub fn write_usize(&mut self, ptr: Pointer, n: u64) -> EvalResult<'tcx> {
+    pub fn write_usize(&mut self, ptr: MemoryPointer, n: u64) -> EvalResult<'tcx> {
         let size = self.pointer_size();
         self.write_uint(ptr, n as u128, size)
     }
 
     /*
-    pub fn write_f32(&mut self, ptr: Pointer, f: f32) -> EvalResult<'tcx> {
+    pub fn write_f32(&mut self, ptr: MemoryPointer, f: f32) -> EvalResult<'tcx> {
         let endianness = self.endianness();
         let align = self.layout.f32_align.abi();
         let b = self.get_bytes_mut(ptr, 4, align)?;
@@ -1190,7 +1190,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    pub fn write_f64(&mut self, ptr: Pointer, f: f64) -> EvalResult<'tcx> {
+    pub fn write_f64(&mut self, ptr: MemoryPointer, f: f64) -> EvalResult<'tcx> {
         let endianness = self.endianness();
         let align = self.layout.f64_align.abi();
         let b = self.get_bytes_mut(ptr, 8, align)?;
@@ -1198,12 +1198,12 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }*/
 
-    pub fn read_f32(&self, ptr: Pointer) -> EvalResult<'tcx, f32> {
+    pub fn read_f32(&self, ptr: MemoryPointer) -> EvalResult<'tcx, f32> {
         self.get_bytes(ptr, 4, self.layout.f32_align.abi())
             .map(|b| read_target_f32(self.endianness(), b).unwrap())
     }
 
-    pub fn read_f64(&self, ptr: Pointer) -> EvalResult<'tcx, f64> {
+    pub fn read_f64(&self, ptr: MemoryPointer) -> EvalResult<'tcx, f64> {
         self.get_bytes(ptr, 8, self.layout.f64_align.abi())
             .map(|b| read_target_f64(self.endianness(), b).unwrap())
     }
@@ -1301,7 +1301,7 @@ fn read_target_f64(endianness: layout::Endian, sbytes: &[SByte])
 
 /// Relocations
 impl<'a, 'tcx> Memory<'a, 'tcx> {
-    fn relocations(&self, ptr: Pointer, size: u64)
+    fn relocations(&self, ptr: MemoryPointer, size: u64)
         -> EvalResult<'tcx, btree_map::Range<u64, AllocId>>
     {
         let ptr_offset = match ptr.offset {
@@ -1314,7 +1314,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(self.get(ptr.alloc_id)?.relocations.range(start..end))
     }
 
-    fn clear_relocations(&mut self, ptr: Pointer, size: u64) -> EvalResult<'tcx> {
+    fn clear_relocations(&mut self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx> {
         // HACK: return early if we know there is nothing to clear. This helps
         // especially in the case where `ptr` is abstract.
         if self.get(ptr.alloc_id)?.relocations.is_empty() {
@@ -1347,7 +1347,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         Ok(())
     }
 
-    fn check_relocation_edges(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx> {
+    fn check_relocation_edges(&self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx> {
         let overlapping_start = self.relocations(ptr, 0)?.count();
         let overlapping_end = self.relocations(ptr.offset(size, self.layout)?, 0)?.count();
         if overlapping_start + overlapping_end != 0 {
@@ -1361,7 +1361,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
 /// Undefined bytes
 impl<'a, 'tcx> Memory<'a, 'tcx> {
     // FIXME(solson): This is a very naive, slow version.
-    fn copy_undef_mask(&mut self, src: Pointer, dest: Pointer, size: u64) -> EvalResult<'tcx> {
+    fn copy_undef_mask(&mut self, src: MemoryPointer, dest: MemoryPointer, size: u64) -> EvalResult<'tcx> {
         // The bits have to be saved locally before writing to dest in case src and dest overlap.
         assert_eq!(size as usize as u64, size);
         match (src.offset, dest.offset) {
@@ -1381,7 +1381,7 @@ impl<'a, 'tcx> Memory<'a, 'tcx> {
         }
     }
 
-    fn check_defined(&self, ptr: Pointer, size: u64) -> EvalResult<'tcx> {
+    fn check_defined(&self, ptr: MemoryPointer, size: u64) -> EvalResult<'tcx> {
         let alloc = self.get(ptr.alloc_id)?;
         match ptr.offset {
             PointerOffset::Concrete(ptr_offset) => {
diff --git a/src/operator.rs b/src/operator.rs
index 3ccbffc24debd79b96f25e84d301068eeb5f0aba..b8941379672f341c2605c22154fa0fe21a9d6eb2 100644
--- a/src/operator.rs
+++ b/src/operator.rs
@@ -7,7 +7,7 @@ use std::cmp::Ordering;
 use error::{EvalError, EvalResult};
 use eval_context::{EvalContext, ValTy};
 use lvalue::Lvalue;
-use memory::{Pointer, PointerOffset, SByte};
+use memory::{MemoryPointer, PointerOffset, SByte};
 use value::{
     PrimVal,
     PrimValKind,
@@ -303,13 +303,13 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     fn ptr_int_arithmetic(
         &self,
         bin_op: mir::BinOp,
-        left: Pointer,
+        left: MemoryPointer,
         right: i128,
         signed: bool,
     ) -> EvalResult<'tcx, (PrimVal, bool)> {
         use rustc::mir::BinOp::*;
 
-        fn map_to_primval((res, over) : (Pointer, bool)) -> (PrimVal, bool) {
+        fn map_to_primval((res, over) : (MemoryPointer, bool)) -> (PrimVal, bool) {
             (PrimVal::Ptr(res), over)
         }
 
@@ -332,7 +332,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                 let right = right as u64;
                 if right & base_mask == base_mask {
                     // Case 1: The base address bits are all preserved, i.e., right is all-1 there
-                    (PrimVal::Ptr(Pointer::new(left.alloc_id, left_offset & right)), false)
+                    (PrimVal::Ptr(MemoryPointer::new(left.alloc_id, left_offset & right)), false)
                 } else if right & base_mask == 0 {
                     // Case 2: The base address bits are all taken away, i.e., right is all-0 there
                     (PrimVal::from_u128((left_offset & right) as u128), false)
@@ -413,9 +413,9 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     fn abstract_ptr_ops(
         &mut self,
         bin_op: mir::BinOp,
-        left: Pointer,
+        left: MemoryPointer,
         _left_kind: PrimValKind,
-        right: Pointer,
+        right: MemoryPointer,
         _right_kind: PrimValKind,
     ) -> EvalResult<'tcx, (PrimVal, bool)> {
         use rustc::mir::BinOp::*;
diff --git a/src/terminator/intrinsic.rs b/src/terminator/intrinsic.rs
index 15873f85f9756fee5fb966f6cc86e50450e5c240..f3a4d1345bcc61fef9951e91f20751062b7ed65e 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};
+use memory::{MemoryPointer};
 use value::{PrimVal, PrimValKind, Value};
 
 impl<'a, 'tcx> EvalContext<'a, 'tcx> {
@@ -331,7 +331,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
                         ptr.to_ptr()?.offset.as_primval(),
                         byte_offset,
                         PrimValKind::U64);
-                    let new_ptr = Pointer::with_primval_offset(ptr.to_ptr()?.alloc_id, new_offset);
+                    let new_ptr = MemoryPointer::with_primval_offset(ptr.to_ptr()?.alloc_id, new_offset);
                     self.write_primval(dest, PrimVal::Ptr(new_ptr), dest_ty)?;
                 }
             }
diff --git a/src/traits.rs b/src/traits.rs
index ebbae109c86d90cafe8ee180eb13a6c7b8492ed4..6cf916da2790a3ba2c35a8bc443992e63bf9081c 100644
--- a/src/traits.rs
+++ b/src/traits.rs
@@ -1,7 +1,7 @@
 use rustc::traits::{self, Reveal};
 
 use eval_context::EvalContext;
-use memory::{Pointer};
+use memory::{MemoryPointer};
 use value::{Value, PrimVal};
 
 use rustc::hir::def_id::DefId;
@@ -44,7 +44,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
     /// The `trait_ref` encodes the erased self type. Hence if we are
     /// making an object `Foo<Trait>` from a value of type `Foo<T>`, then
     /// `trait_ref` would map `T:Trait`.
-    pub fn get_vtable(&mut self, ty: Ty<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> EvalResult<'tcx, Pointer> {
+    pub fn get_vtable(&mut self, ty: Ty<'tcx>, trait_ref: ty::PolyTraitRef<'tcx>) -> EvalResult<'tcx, MemoryPointer> {
         debug!("get_vtable(trait_ref={:?})", trait_ref);
 
         let size = self.type_size(trait_ref.self_ty())?.expect("can't create a vtable for an unsized type");
@@ -74,7 +74,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
         Ok(vtable)
     }
 
-    pub fn read_drop_type_from_vtable(&mut self, vtable: Pointer) -> EvalResult<'tcx, Option<ty::Instance<'tcx>>> {
+    pub fn read_drop_type_from_vtable(&mut self, vtable: MemoryPointer) -> EvalResult<'tcx, Option<ty::Instance<'tcx>>> {
         // we don't care about the pointee type, we just want a pointer
         let np = self.tcx.mk_nil_ptr();
         let drop_fn = match self.read_ptr(vtable, np)? {
@@ -89,7 +89,7 @@ impl<'a, 'tcx> EvalContext<'a, 'tcx> {
 
     pub fn read_size_and_align_from_vtable(
         &self,
-        vtable: Pointer,
+        vtable: MemoryPointer,
     ) -> EvalResult<'tcx, (Size, Align)> {
         let pointer_size = self.memory.pointer_size();
         let size = self.memory.read_usize(vtable.offset(pointer_size, self.data_layout())?)?;
diff --git a/src/value.rs b/src/value.rs
index c83e6630267f445411c33647edf8ae0826e4472d..a5c915e6ce14aba81feb885cb8774605f10628a3 100644
--- a/src/value.rs
+++ b/src/value.rs
@@ -2,7 +2,7 @@ use std::mem::transmute;
 use rustc::ty::layout::TargetDataLayout;
 
 use error::{EvalError, EvalResult};
-use memory::{Memory, Pointer, SByte};
+use memory::{Memory, MemoryPointer, SByte};
 
 pub(super) fn bytes_to_f32(bytes: u128) -> f32 {
     unsafe { transmute::<u32, f32>(bytes as u32) }
@@ -36,7 +36,7 @@ pub(super) fn bytes_to_bool(n: u128) -> bool {
 /// operations and fat pointers. This idea was taken from rustc's trans.
 #[derive(Clone, Copy, Debug)]
 pub enum Value {
-    ByRef(Pointer),
+    ByRef(MemoryPointer),
     ByVal(PrimVal),
     ByValPair(PrimVal, PrimVal),
 }
@@ -55,8 +55,8 @@ pub enum PrimVal {
 
     /// A pointer into an `Allocation`. An `Allocation` in the `memory` module has a list of
     /// relocations, but a `PrimVal` is only large enough to contain one, so we just represent the
-    /// relocation and its associated offset together as a `Pointer` here.
-    Ptr(Pointer),
+    /// relocation and its associated offset together as a `MemoryPointer` here.
+    Ptr(MemoryPointer),
 
     /// An undefined `PrimVal`, for representing values that aren't safe to examine, but are safe
     /// to copy around, just like undefined bytes in an `Allocation`.
@@ -86,7 +86,7 @@ impl<'a, 'tcx: 'a> Value {
     pub(super) fn into_ptr_vtable_pair(
         &self,
         mem: &Memory<'a, 'tcx>
-    ) -> EvalResult<'tcx, (PrimVal, Pointer)> {
+    ) -> EvalResult<'tcx, (PrimVal, MemoryPointer)> {
         use self::Value::*;
         match *self {
             ByRef(ref_ptr) => {
@@ -158,7 +158,7 @@ impl<'tcx> PrimVal {
         }
     }
 
-    pub fn to_ptr(self) -> EvalResult<'tcx, Pointer> {
+    pub fn to_ptr(self) -> EvalResult<'tcx, MemoryPointer> {
         match self {
             PrimVal::Bytes(_) => Err(EvalError::ReadBytesAsPointer),
             PrimVal::Abstract(_) => unimplemented!(),