broken, but at least finding poitner to internal bytes in allocation. now need to make allocid the memory address

Author: Ellen Arteca

ffi_tests/Cargo.lock

@@ -0,0 +1,9 @@
+[package]
+name = "ffi-tests"
+version = "0.1.0"
+edition = "2018"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+#
+[build-dependencies]
+cc = "1.0"

ffi_tests/Cargo.toml

@@ -0,0 +1,7 @@
+extern crate cc;
+
+fn main() {
+        cc::Build::new()
+                    .file("src/test.c")
+                            .compile("libtest.a");
+}

ffi_tests/build.rs

@@ -0,0 +1,48 @@
+extern "C" {
+        fn get_num(x: i32) -> i32;
+        fn printer();
+        fn get_dbl(x: i32) -> f64;
+        fn test_stack_spill(a:i32, b:i32, c:i32, d:i32, e:i32, f:i32, g:i32, h:i32, i:i32, j:i32, k:i32, l:i32) -> i32;
+        fn pointer_test() -> *mut i32;
+        fn ptr_printer(x: *mut i32);
+        fn ddref_print(x: *mut *mut i32);
+}
+
+//extern "C" { pub fn get_num () -> :: std :: os :: raw :: c_int ; }
+
+fn main() {
+        //let x;
+        unsafe {
+            let mut y: i32 = 45;
+            let mut z = (&mut y) as *mut i32;
+            let mut z = &mut z;
+            println!("{:?}, {:?}, {:?}", z, *z, **z);
+            println!("as **i32 in rust: {:?}", (z as *mut *mut i32));
+             println!("as **i32 in rust: {:?}", **(z as *mut *mut i32));
+            ddref_print(z as *mut *mut i32);
+                /*
+                    //println!("{}", get_num());
+                    printer();
+                    x = get_num(1);
+//                    let y = get_dbl(x);
+    
+                    println!("{}", x);
+                    printer();
+                    let y = test_stack_spill(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12);
+                    println!("{}", y);
+
+                    let ptr = pointer_test();
+                    
+                    ptr_printer(ptr);
+                    println!("In Rust this pointer has value: {:?}", *ptr);
+
+                    *ptr = 10;
+                    ptr_printer(ptr);
+                    println!("In Rust this pointer has value: {:?}", *ptr);
+
+                    //let ptr2 = pointer_test();
+                    //println!("{:?}, {:?}", *ptr, *ptr2);*/
+        }
+        //println!("x: {:?}", x);
+        //println!("rjeiworjweio");
+}

ffi_tests/src/libtestlib.so

@@ -0,0 +1,34 @@
+#include <stdio.h>
+#include <stdlib.h>
+
+void ddref_print(int **x) {
+  printf("PTR %d\n", x);
+  printf("*PTR %d\n", *x);
+  printf("**PTR %d\n", **x);
+}
+
+int get_num(int x) {
+  return 2 + x;
+}
+
+int* pointer_test() {
+      int *point = malloc(sizeof(int)); 
+      *point=1;  
+      return point;
+}
+
+void ptr_printer(int *x) {
+  printf("pointer has value: %d\n", *x);
+}
+
+double get_dbl(int x) {
+  return 2.75 + x;
+}
+
+void printer() {
+  printf("printing from C\n");
+}
+
+int test_stack_spill(int a, int b, int c, int d, int e, int f, int g, int h, int i, int j, int k, int l) {
+  return a+b+c+d+e+f+g+h+i+j+k+l;
+}

ffi_tests/src/main.rs

@@ -135,6 +135,7 @@ pub enum Provenance {
         sb: SbTag,
     },
     Wildcard,
+    CHasAccess,
 }
 
 /// The "extra" information a pointer has over a regular AllocId.
@@ -145,12 +146,12 @@ pub enum ProvenanceExtra {
 }
 
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-static_assert_size!(Pointer<Provenance>, 24);
+static_assert_size!(Pointer<Provenance>, 32);
 // FIXME: this would with in 24bytes but layout optimizations are not smart enough
 // #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
 //static_assert_size!(Pointer<Option<Provenance>>, 24);
 #[cfg(all(target_arch = "x86_64", target_pointer_width = "64"))]
-static_assert_size!(ScalarMaybeUninit<Provenance>, 32);
+static_assert_size!(ScalarMaybeUninit<Provenance>, 40);
 
 impl interpret::Provenance for Provenance {
     /// We use absolute addresses in the `offset` of a `Pointer<Provenance>`.
@@ -177,6 +178,9 @@ impl interpret::Provenance for Provenance {
             Provenance::Wildcard => {
                 write!(f, "[wildcard]")?;
             }
+            Provenance::CHasAccess => {
+                write!(f, "[c has access]")?;
+            }
         }
 
         Ok(())
@@ -186,6 +190,7 @@ impl interpret::Provenance for Provenance {
         match self {
             Provenance::Concrete { alloc_id, .. } => Some(alloc_id),
             Provenance::Wildcard => None,
+            Provenance::CHasAccess => None,
         }
     }
 }
@@ -219,6 +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,
 }
 
 /// Precomputed layouts of primitive types
@@ -692,6 +698,16 @@ 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 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(
@@ -729,12 +745,14 @@ 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,
             },
             |ptr| ecx.global_base_pointer(ptr),
         )?;
@@ -794,7 +812,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         match ptr.provenance {
             Provenance::Concrete { alloc_id, sb } =>
                 intptrcast::GlobalStateInner::expose_ptr(ecx, alloc_id, sb),
-            Provenance::Wildcard => {
+            Provenance::Wildcard | Provenance::CHasAccess => {
                 // No need to do anything for wildcard pointers as
                 // their provenances have already been previously exposed.
                 Ok(())
@@ -813,7 +831,7 @@ impl<'mir, 'tcx> Machine<'mir, 'tcx> for Evaluator<'mir, 'tcx> {
         rel.map(|(alloc_id, size)| {
             let sb = match ptr.provenance {
                 Provenance::Concrete { sb, .. } => ProvenanceExtra::Concrete(sb),
-                Provenance::Wildcard => ProvenanceExtra::Wildcard,
+                Provenance::Wildcard | Provenance::CHasAccess => ProvenanceExtra::Wildcard,
             };
             (alloc_id, size, sb)
         })

ffi_tests/src/test.c

@@ -37,7 +37,7 @@ impl<K: Hash + Eq, V> Default for MonoHashMap<K, V> {
     }
 }
 
-impl<K: Hash + Eq, V> AllocMap<K, V> for MonoHashMap<K, V> {
+impl<K: Hash + Eq, V: std::fmt::Debug> AllocMap<K, V> for MonoHashMap<K, V> {
     #[inline(always)]
     fn contains_key<Q: ?Sized + Hash + Eq>(&mut self, k: &Q) -> bool
     where
@@ -48,6 +48,7 @@ impl<K: Hash + Eq, V> 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)
     }