Finished merging errors

Author: AaronHTan

src/tools/bsan/bsan-rt/src/global.rs

@@ -17,6 +17,7 @@ use hashbrown::{DefaultHashBuilder, HashMap};
 use rustc_hash::FxBuildHasher;
 
 use crate::*;
+use crate::shadow::ShadowHeap;
 
 /// Every action that requires a heap allocation must be performed through a globally
 /// accessible, singleton instance of `GlobalCtx`. Initializing or obtaining
@@ -43,17 +44,21 @@ impl GlobalCtx {
     /// This function will also initialize our shadow heap
     fn new(hooks: BsanHooks) -> Self {
         Self {
-            hooks,
+            hooks: hooks.clone(),
             next_alloc_id: AtomicUsize::new(AllocId::min().get()),
             next_thread_id: AtomicUsize::new(0),
-            shadow_heap: ShadowHeap::new(hooks),
+            shadow_heap: ShadowHeap::new(&hooks),
         }
     }
 
     pub fn shadow_heap(&self) -> &ShadowHeap<Provenance> {
         &self.shadow_heap
     }
 
+    pub fn hooks(&self) -> &BsanHooks {
+        &self.hooks
+    }
+
     pub fn new_block<T>(&self, num_elements: NonZeroUsize) -> Block<T> {
         let layout = Layout::array::<T>(num_elements.into()).unwrap();
         let size = NonZeroUsize::new(layout.size()).unwrap();

src/tools/bsan/bsan-rt/src/lib.rs

@@ -152,13 +152,19 @@ pub type Span = usize;
 /// and a borrow tag. We also include a pointer to the "lock" location for the allocation,
 /// which contains all other metadata used to detect undefined behavior.
 #[repr(C)]
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 pub struct Provenance {
     pub alloc_id: AllocId,
     pub bor_tag: BorTag,
     pub alloc_info: *mut c_void,
 }
 
+impl Default for Provenance {
+    fn default() -> Self {
+        Provenance::null()
+    }
+}   
+
 impl Provenance {
     /// The default provenance value, which is assigned to dangling or invalid
     /// pointers.
@@ -258,14 +264,14 @@ extern "C" fn bsan_shadow_clear(addr: usize, access_size: usize) {}
 /// the result in the return pointer.
 #[no_mangle]
 unsafe extern "C" fn bsan_load_prov(prov: *mut Provenance, address: usize) {
-    let result = global_ctx().shadow_heap().load_prov(address);
+    let result = (*global_ctx()).shadow_heap().load_prov(address);
     *prov = result;
 }
 
 /// Stores the given provenance value into shadow memory at the location for the given address.
 #[no_mangle]
 unsafe extern "C" fn bsan_store_prov(provenance: *const Provenance, address: usize) {
-    let heap = &(*global_ctx()).shadow_heap();
+    let heap = (*global_ctx()).shadow_heap();
     heap.store_prov(provenance, address);
 }
 /// Pushes a shadow stack frame

src/tools/bsan/bsan-rt/src/shadow.rs

@@ -134,9 +134,9 @@ pub struct ShadowHeap<T> {
     l1: L1<T>,
 }
 
-impl<T: Default + Copy> Default for ShadowHeap<T> {
+impl<T> Default for ShadowHeap<T> {
     fn default() -> Self {
-        Self { l1: unsafe { L1::new(global_ctx().hooks()) } }
+        Self { l1: unsafe { L1::new((*global_ctx()).hooks()) } }
     }
 }
 
@@ -146,7 +146,8 @@ impl<T> ShadowHeap<T> {
     }
 }
 
-impl<T: Default + Copy> ShadowHeap<T> {
+impl<T : Default + Copy> ShadowHeap<T> {
+
     pub unsafe fn load_prov(&self, address: usize) -> T {
         let (l1_addr, l2_addr) = table_indices(address);
         let mut l2 = (*self.l1.entries)[l1_addr];
@@ -165,7 +166,7 @@ impl<T: Default + Copy> ShadowHeap<T> {
         let mut l2 = (*self.l1.entries)[l1_addr];
         if l2.is_null() {
             let l2_addr = unsafe { (*self.l1.entries).as_ptr().add(l1_addr) as *mut c_void };
-            l2 = &mut L2::new(global_ctx().hooks(), l2_addr);
+            l2 = &mut L2::new((*global_ctx()).hooks(), l2_addr);
             (*self.l1.entries)[l1_addr] = l2;
         }