fixup! Optimize compat_fn!, add compat_fn_lazy!, add unicows support

Author: mbilker

library/std/src/sys/windows/compat.rs

@@ -147,7 +147,7 @@ macro_rules! compat_fn_with_fallback {
             use super::*;
             use crate::mem;
             use crate::ffi::CStr;
-            use crate::sync::atomic::{AtomicPtr, Ordering};
+            use crate::sync::atomic::{AtomicBool, AtomicPtr, Ordering};
             use crate::sys::compat::Module;
 
             type F = unsafe extern "system" fn($($argtype),*) -> $rettype;
@@ -158,6 +158,7 @@ macro_rules! compat_fn_with_fallback {
             /// If it succeeds, `PTR` is set to the address of that symbol.
             /// If it fails, then `PTR` is set to `fallback`.
             static PTR: AtomicPtr<c_void> = AtomicPtr::new(load as *mut _);
+            static AVAILABLE: AtomicBool = AtomicBool::new(false);
 
             unsafe extern "system" fn load($($argname: $argtype),*) -> $rettype {
                 let func = load_from_module(Module::new($module));
@@ -172,9 +173,11 @@ macro_rules! compat_fn_with_fallback {
                         .or_else(|| module.and_then(|m| m.proc_address(SYMBOL_NAME)))
                     {
                         PTR.store(f.as_ptr(), Ordering::Relaxed);
+                        AVAILABLE.store(true, Ordering::Relaxed);
                         mem::transmute(f)
                     } else {
                         PTR.store(fallback as *mut _, Ordering::Relaxed);
+                        AVAILABLE.store(false, Ordering::Relaxed);
                         fallback
                     }
                 }
@@ -185,6 +188,20 @@ macro_rules! compat_fn_with_fallback {
                 $fallback_body
             }
 
+            pub unsafe fn available() -> bool {
+                // Quickly return if already available
+                if AVAILABLE.load(Ordering::Relaxed) {
+                    return true;
+                }
+
+                // Try to avoid fetching the load status every time
+                if PTR.load(Ordering::Relaxed) == load as *mut _ {
+                    let _ = load_from_module(Module::new($module));
+                }
+
+                AVAILABLE.load(Ordering::Relaxed)
+            }
+
             #[inline(always)]
             pub unsafe fn call($($argname: $argtype),*) -> $rettype {
                 let func: F = mem::transmute(PTR.load(Ordering::Relaxed));