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::{AtomicBool, AtomicPtr, Ordering};
+            use crate::sync::atomic::{AtomicPtr, Ordering};
             use crate::sys::compat::Module;
 
             type F = unsafe extern "system" fn($($argtype),*) -> $rettype;
@@ -158,7 +158,6 @@ 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));
@@ -173,11 +172,9 @@ 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
                     }
                 }
@@ -189,17 +186,21 @@ macro_rules! compat_fn_with_fallback {
             }
 
             pub unsafe fn available() -> bool {
-                // Quickly return if already available
-                if AVAILABLE.load(Ordering::Relaxed) {
+                let func = PTR.load(Ordering::Relaxed);
+
+                // Check the function pointer to see if it is not equal to `load`
+                if func == fallback as *mut _ {
+                    return false;
+                } else if func != load as *mut _ {
                     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));
-                }
+                // Otherwise, the function pointer should be resolved
+                let _ = load_from_module(Module::new($module));
 
-                AVAILABLE.load(Ordering::Relaxed)
+                // After resolution, the function pointer will only point to `fallback` if
+                // the target function was not found
+                PTR.load(Ordering::Relaxed) == fallback as *mut _
             }
 
             #[inline(always)]