unsafe-wrap some of the win32 backtrace impl

Author: workingjubilee

src/backtrace/win32.rs

@@ -97,11 +97,11 @@ struct MyContext(CONTEXT);
 #[inline(always)]
 pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
     // Allocate necessary structures for doing the stack walk
-    let process = GetCurrentProcess();
-    let thread = GetCurrentThread();
+    let process = unsafe { GetCurrentProcess() };
+    let thread = unsafe { GetCurrentThread() };
 
-    let mut context = mem::zeroed::<MyContext>();
-    RtlCaptureContext(&mut context.0);
+    let mut context = unsafe { mem::zeroed::<MyContext>() };
+    unsafe { RtlCaptureContext(&mut context.0) };
 
     // Ensure this process's symbols are initialized
     let dbghelp = match dbghelp::init() {
@@ -112,14 +112,15 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
     let function_table_access = dbghelp.SymFunctionTableAccess64();
     let get_module_base = dbghelp.SymGetModuleBase64();
 
-    let process_handle = GetCurrentProcess();
+    let process_handle = unsafe { GetCurrentProcess() };
 
     // Attempt to use `StackWalkEx` if we can, but fall back to `StackWalk64`
     // since it's in theory supported on more systems.
-    match (*dbghelp.dbghelp()).StackWalkEx() {
+    match unsafe { (*dbghelp.dbghelp()).StackWalkEx() } {
         #[allow(non_snake_case)]
         Some(StackWalkEx) => {
-            let mut inner: STACKFRAME_EX = mem::zeroed();
+            // It is a C struct meant to be used in classic "out-pointer" fashion, so we zero it
+            let mut inner: STACKFRAME_EX = unsafe { mem::zeroed() };
             inner.StackFrameSize = mem::size_of::<STACKFRAME_EX>() as u32;
             let mut frame = super::Frame {
                 inner: Frame {
@@ -133,7 +134,7 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
                 _ => unreachable!(),
             };
 
-            while StackWalkEx(
+            while unsafe { StackWalkEx(
                 image as u32,
                 process,
                 thread,
@@ -144,9 +145,9 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
                 Some(get_module_base),
                 None,
                 0,
-            ) == TRUE
+            ) == TRUE }
             {
-                frame.inner.base_address = get_module_base(process_handle, frame.ip() as _) as _;
+                frame.inner.base_address = unsafe { get_module_base(process_handle, frame.ip() as _) as _ };
 
                 if !cb(&frame) {
                     break;
@@ -156,7 +157,8 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
         None => {
             let mut frame = super::Frame {
                 inner: Frame {
-                    stack_frame: StackFrame::Old(mem::zeroed()),
+                    // It is a C struct meant to be used in classic "out-pointer" fashion, so we zero it
+                    stack_frame: StackFrame::Old(unsafe { mem::zeroed() }),
                     base_address: 0 as _,
                 },
             };
@@ -166,7 +168,7 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
                 _ => unreachable!(),
             };
 
-            while dbghelp.StackWalk64()(
+            while unsafe { dbghelp.StackWalk64()(
                 image as u32,
                 process,
                 thread,
@@ -176,9 +178,9 @@ pub unsafe fn trace(cb: &mut dyn FnMut(&super::Frame) -> bool) {
                 Some(function_table_access),
                 Some(get_module_base),
                 None,
-            ) == TRUE
+            ) == TRUE }
             {
-                frame.inner.base_address = get_module_base(process_handle, frame.ip() as _) as _;
+                frame.inner.base_address = unsafe { get_module_base(process_handle, frame.ip() as _) as _ };
 
                 if !cb(&frame) {
                     break;