store the pointer in the allocextra -- now just need to make it the allocid

Author: Ellen Arteca

src/machine.rs

@@ -224,7 +224,7 @@ pub struct AllocExtra {
     /// Weak memory emulation via the use of store buffers,
     ///  this is only added if it is enabled.
     pub weak_memory: Option<weak_memory::AllocExtra>,
-    // pub real_pointer: u64,
+    pub real_pointer: *const u8,
 }
 
 /// Precomputed layouts of primitive types
@@ -698,16 +698,10 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         alloc: Cow<'b, Allocation>,
         kind: Option<MemoryKind<Self::MemoryKind>>,
     ) -> InterpResult<'tcx, Cow<'b, Allocation<Self::Provenance, Self::AllocExtra>>> {
-        let (size, _, _) = ecx.get_alloc_info(id);
-        let fake_range = AllocRange{ start: rustc_target::abi::Size::ZERO, size: size};
-        let ree = ecx.memory.alloc_map().get(id).unwrap().1.get_bytes_with_uninit_and_ptr(ecx, fake_range).unwrap();
-                                        
-        // let bytes_ptr = alloc.get_bytes( ecx, fake_range);
-        // unsafe {
-        //     if bytes_ptr.is_ok() {//&& id.0 > std::num::NonZeroU64::new(1600).unwrap(){
-        //         // println!("{:?}, {:?}", id, *(bytes_ptr.unwrap().as_ptr()));
-        //     }
-        // }
+        let size = alloc.size();
+        let alloc_range = AllocRange{ start: rustc_target::abi::Size::ZERO, size: size};
+        let alloc_bytes_ptr = alloc.get_bytes_with_uninit_and_ptr(ecx, alloc_range).unwrap().as_ptr();
+ 
         let kind = kind.expect("we set our STATIC_KIND so this cannot be None");
         if ecx.machine.tracked_alloc_ids.contains(&id) {
             register_diagnostic(NonHaltingDiagnostic::CreatedAlloc(
@@ -745,14 +739,13 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         } else {
             None
         };
-        // println!("{:?}", ree.as_ptr() as u64);
         let alloc: Allocation<Provenance, Self::AllocExtra> = alloc.adjust_from_tcx(
             &ecx.tcx,
             AllocExtra {
                 stacked_borrows: stacks.map(RefCell::new),
                 data_race: race_alloc,
                 weak_memory: buffer_alloc,
-                // real_pointer: 0,
+                real_pointer: alloc_bytes_ptr,
             },
             |ptr| ecx.global_base_pointer(ptr),
         )?;

src/mono_hash_map.rs

@@ -37,7 +37,7 @@ impl<K: Hash + Eq, V> Default for MonoHashMap<K, V> {
     }
 }
 
-impl<K: Hash + Eq, V: std::fmt::Debug> AllocMap<K, V> for MonoHashMap<K, V> {
+impl<K: Hash + Eq, V> AllocMap<K, V> for MonoHashMap<K, V> {
     #[inline(always)]
     fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
     where
@@ -48,7 +48,6 @@ impl<K: Hash + Eq, V: std::fmt::Debug> AllocMap<K, V> for MonoHashMap<K, V> {
 
     #[inline(always)]
     fn insert(&mut self, k: K, v: V) -> Option<V> {
-        println!("WHY: {:?}", v);
         self.0.get_mut().insert(k, Box::new(v)).map(|x| *x)
     }
 

src/shims/ffi_support.rs

@@ -81,28 +81,9 @@ pub trait EvalContextExt<'mir, 'tcx: 'mir>: crate::MiriEvalContextExt<'mir, 'tcx
                                 match k {
                                     ScalarMaybeUninit::Scalar(Scalar::Ptr(ptr, sz)) => {
                                         let (alloc_id, _, _) = cx.ptr_get_alloc_id(ptr.into())?;
-                                        let (size, align, _) = cx.get_alloc_info(alloc_id);
-                                        let fake_range = AllocRange{ start: rustc_target::abi::Size::ZERO, size: size};
-                                        println!("{:?}, {:?}", size, align);
-                                        let alloc = cx.get_ptr_alloc(ptr.into(), size, align)?.unwrap();
-                                        let wtf = alloc.read_integer(alloc_range(rustc_target::abi::Size::ZERO, size));
-                                        println!("UMM {:?}", wtf);
-                                        let ree = cx.memory.alloc_map().get(alloc_id).unwrap().1.get_bytes_with_uninit_and_ptr(cx, fake_range).unwrap();
-                                        println!("{:?}", ree.as_ptr());
-                                        let bytes = cx.read_bytes_ptr(ptr.into(), size);
-                                        println!("WHAT {:?}", bytes);
-                                        // println!("{:?}", ptr.into_parts().0);
-                                        // let ree = &ptr.into_parts().1.bytes();
-                                        // println!("{:?}", self.memory);
-                                        // println!("{:?}", ptr.get_alloc_id());
-                                        // unsafe {
-                                        //     println!("{:?}", *(ree as *const u64));
-                                        //     println!("{:?}", *(ptr.into_parts().1.bytes() as *mut u64));
-                                        // }
-                                        // println!("REE {:?}", intptrcast::GlobalStateInner::rel_ptr_to_addr(cx, ptr));
-                                        // let the_int = s.assert_int();
-                                        // println!("{:?}", the_int.try_to_u64().unwrap());
-                                        let inner_carg = CArg::ConstPtrUInt8(unsafe{ree.as_ptr()});
+                                        let ree = cx.memory.alloc_map().get(alloc_id).unwrap().1.extra.real_pointer;//get_bytes_with_uninit_and_ptr(cx, fake_range).unwrap();
+                                        println!("{:?}", ree);
+                                        let inner_carg = CArg::ConstPtrUInt8(ree);
                                         return Ok(CArg::RecMutPtrCarg(Box::new(inner_carg)));
                                         // return Ok(CArg::USize(the_int.try_to_u64().unwrap().try_into().unwrap()));
                                         // println!("{:?}", s.assert_int())