support change to miri backtrace

Author: beepster4096

src/backtrace/miri.rs

@@ -2,15 +2,16 @@ use alloc::boxed::Box;
 use core::ffi::c_void;
 
 extern "Rust" {
-    fn miri_get_backtrace(flags: u64) -> Box<[*mut ()]>;
+    fn miri_get_backtrace(flags: u64) -> *mut [*mut ()];
     fn miri_resolve_frame(ptr: *mut (), flags: u64) -> MiriFrame;
+    fn miri_deallocate_backtrace(ptr: *mut ());
 }
 
 #[derive(Clone, Debug)]
 #[repr(C)]
 pub struct MiriFrame {
-    pub name: Box<[u8]>,
-    pub filename: Box<[u8]>,
+    pub name: *mut [u8],
+    pub filename: *mut [u8],
     pub lineno: u32,
     pub colno: u32,
     pub fn_ptr: *mut c_void,
@@ -19,7 +20,11 @@ pub struct MiriFrame {
 #[derive(Debug, Clone)]
 pub struct Frame {
     pub addr: *mut c_void,
-    pub inner: MiriFrame,
+    pub name: Box<[u8]>,
+    pub filename: Box<[u8]>,
+    pub lineno: u32,
+    pub colno: u32,
+    pub fn_ptr: *mut c_void,
 }
 
 // SAFETY: Miri guarantees that the returned pointer
@@ -37,7 +42,7 @@ impl Frame {
     }
 
     pub fn symbol_address(&self) -> *mut c_void {
-        self.inner.fn_ptr
+        self.fn_ptr
     }
 
     pub fn module_base_address(&self) -> Option<*mut c_void> {
@@ -55,16 +60,35 @@ pub fn resolve_addr(ptr: *mut c_void) -> Frame {
     // SAFETY: Miri will stop execution with an error if this pointer
     // is invalid.
     let frame: MiriFrame = unsafe { miri_resolve_frame(ptr as *mut (), 0) };
+
+    // SAFETY: Miri guarantees that these pointers are valid
+    let name = unsafe { (&*frame.name).into() };
+    let filename = unsafe { (&*frame.filename).into() };
+
+    // SAFETY: these pointers are from `miri_resolve_frame`
+    unsafe {
+        miri_deallocate_backtrace(frame.name as *mut ());
+        miri_deallocate_backtrace(frame.filename as *mut ());
+    }
+
     Frame {
         addr: ptr,
-        inner: frame,
+        name,
+        filename,
+        lineno: frame.lineno,
+        colno: frame.colno,
+        fn_ptr: frame.fn_ptr,
     }
 }
 
 pub unsafe fn trace_unsynchronized<F: FnMut(&super::Frame) -> bool>(mut cb: F) {
-    let frames = miri_get_backtrace(0);
+    let frames_ptr = miri_get_backtrace(0);
+    let frames = &*frames_ptr;
+
     for ptr in frames.iter() {
         let frame = resolve_addr(*ptr as *mut c_void);
         cb(&super::Frame { inner: frame });
     }
+
+    miri_deallocate_backtrace(frames_ptr as *mut ());
 }

src/lib.rs

@@ -93,6 +93,7 @@
     all(feature = "std", target_env = "sgx", target_vendor = "fortanix"),
     feature(sgx_platform)
 )]
+#![cfg_attr(miri, feature(allocator_api))]
 #![warn(rust_2018_idioms)]
 // When we're building as part of libstd, silence all warnings since they're
 // irrelevant as this crate is developed out-of-tree.

src/symbolize/miri.rs

@@ -26,29 +26,29 @@ pub struct Symbol<'a> {
 
 impl<'a> Symbol<'a> {
     pub fn name(&self) -> Option<SymbolName<'_>> {
-        Some(SymbolName::new(&self.inner.inner.name))
+        Some(SymbolName::new(&self.inner.name))
     }
 
     pub fn addr(&self) -> Option<*mut c_void> {
         Some(self.inner.addr)
     }
 
     pub fn filename_raw(&self) -> Option<BytesOrWideString<'_>> {
-        Some(BytesOrWideString::Bytes(&self.inner.inner.filename))
+        Some(BytesOrWideString::Bytes(&self.inner.filename))
     }
 
     pub fn lineno(&self) -> Option<u32> {
-        Some(self.inner.inner.lineno)
+        Some(self.inner.lineno)
     }
 
     pub fn colno(&self) -> Option<u32> {
-        Some(self.inner.inner.colno)
+        Some(self.inner.colno)
     }
 
     #[cfg(feature = "std")]
     pub fn filename(&self) -> Option<&std::path::Path> {
         Some(std::path::Path::new(
-            core::str::from_utf8(&self.inner.inner.filename).unwrap(),
+            core::str::from_utf8(&self.inner.filename).unwrap(),
         ))
     }
 }