Big cleanup

Author: Tomcc

src/lib.rs

@@ -83,6 +83,7 @@ mod symbolize;
 pub use crate::types::BytesOrWideString;
 mod types;
 
+#[cfg(feature = "std")]
 pub use crate::symbolize::clear_symbol_cache;
 
 cfg_if::cfg_if! {

src/symbolize/gimli.rs

@@ -351,7 +351,7 @@ pub unsafe fn clear_symbol_cache() {
     with_cache(|cache| cache.clear());
 }
 
-fn with_mapping_for_path<F>(path: PathBuf, f: F)
+unsafe fn with_mapping_for_path<F>(path: PathBuf, f: F)
 where
     F: FnMut(&Context<'_>),
 {

src/symbolize/mod.rs

@@ -436,24 +436,11 @@ cfg_if::cfg_if! {
 
 mod dladdr;
 
-/// Each resolve() implementation allocates and caches several megabytes worth of symbols,
-/// clear_symbol_cache tries to reclaim that cached memory.
-/// Note: for now, only the Gimli implementation is able to clear its cache.
-#[cfg(feature = "std")]
-pub fn clear_symbol_cache() {    
-    let _guard = crate::lock::lock();
-    unsafe {
-        clear_imp()
-    }
-}
-
 cfg_if::cfg_if! {
     if #[cfg(all(windows, target_env = "msvc", feature = "dbghelp"))] {
         mod dbghelp;
         use self::dbghelp::resolve as resolve_imp;
         use self::dbghelp::Symbol as SymbolImp;
-        unsafe fn noop_clear_symbol_cache() {}
-        use noop_clear_symbol_cache as clear_imp;
     } else if #[cfg(all(
         feature = "std",
         feature = "gimli-symbolize",
@@ -466,7 +453,6 @@ cfg_if::cfg_if! {
         mod gimli;
         use self::gimli::resolve as resolve_imp;
         use self::gimli::Symbol as SymbolImp;
-        use self::gimli::clear_symbol_cache as clear_imp;
     // Note that we only enable coresymbolication on iOS when debug assertions
     // are enabled because it's helpful in debug mode but it looks like apps get
     // rejected from the app store if they use this API, see #92 for more info
@@ -476,34 +462,49 @@ cfg_if::cfg_if! {
         mod coresymbolication;
         use self::coresymbolication::resolve as resolve_imp;
         use self::coresymbolication::Symbol as SymbolImp;
-
-        unsafe fn noop_clear_symbol_cache() {}
-        use noop_clear_symbol_cache as clear_imp;
     } else if #[cfg(all(feature = "libbacktrace",
                         any(unix, all(windows, not(target_vendor = "uwp"), target_env = "gnu")),
                         not(target_os = "fuchsia"),
                         not(target_os = "emscripten")))] {
         mod libbacktrace;
         use self::libbacktrace::resolve as resolve_imp;
         use self::libbacktrace::Symbol as SymbolImp;
-
-        unsafe fn noop_clear_symbol_cache() {}
-        use noop_clear_symbol_cache as clear_imp;
     } else if #[cfg(all(unix,
                         not(target_os = "emscripten"),
                         feature = "dladdr"))] {
         mod dladdr_resolve;
         use self::dladdr_resolve::resolve as resolve_imp;
         use self::dladdr_resolve::Symbol as SymbolImp;
-
-        unsafe fn noop_clear_symbol_cache() {}
-        use noop_clear_symbol_cache as clear_imp;
     } else {
         mod noop;
         use self::noop::resolve as resolve_imp;
         use self::noop::Symbol as SymbolImp;
-
-        unsafe fn noop_clear_symbol_cache() {}
-        use noop_clear_symbol_cache as clear_imp;
     }
 }
+
+cfg_if::cfg_if! {
+    if #[cfg(all(
+        feature = "std",
+        feature = "gimli-symbolize",
+        any(
+            target_os = "linux",
+            target_os = "macos",
+            windows,
+        ),
+    ))] {
+        /// clear_symbol_cache tries to reclaim that cached memory.
+        /// Note: for now, only the Gimli implementation is able to clear its cache.
+        pub fn clear_symbol_cache() {    
+            let _guard = crate::lock::lock();
+            unsafe {
+                self::gimli::clear_symbol_cache();
+            }
+        }
+    } else if #[cfg(feature = "std")] {
+        /// clear_symbol_cache tries to reclaim that cached memory.
+        /// Note: for now, only the Gimli implementation is able to clear its cache.
+        pub fn clear_symbol_cache() {
+            // noop
+        }
+    }
+}