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

Author: mbilker

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

@@ -112,12 +112,25 @@ impl Module {
     ///
     /// This should only be use for modules that exist for the lifetime of std
     /// (e.g. kernel32 and ntdll).
-    pub unsafe fn new(name: &CStr) -> Option<Self> {
+    pub unsafe fn get(name: &CStr) -> Option<Self> {
         // SAFETY: A CStr is always null terminated.
         let module = c::GetModuleHandleA(name.as_ptr().cast::<u8>());
         NonNull::new(module).map(Self)
     }
 
+    /// Try to get a handle to a loaded module. If the module was not loaded, then load
+    /// the module.
+    ///
+    /// # SAFETY
+    ///
+    /// This should only be used for modules that exist for the lifetime of std
+    /// that are not pre-loaded by Windows (e.g. advapi32 and bcrypt)
+    pub unsafe fn load(name: &CStr) -> Option<Self> {
+        // SAFETY: A CStr is always null terminated.
+        let module = c::LoadLibraryA(name.as_ptr().cast::<u8>());
+        NonNull::new(module).map(Self)
+    }
+
     // Try to get the address of a function.
     pub fn proc_address(self, name: &CStr) -> Option<NonNull<c_void>> {
         unsafe {
@@ -135,7 +148,8 @@ pub(crate) const UNICOWS_MODULE_NAME: &CStr = ansi_str!("unicows");
 
 /// Load a function or use a fallback implementation if that fails.
 macro_rules! compat_fn_with_fallback {
-    (pub static $module:ident: &CStr = $name:expr; $(
+    (pub static $module:ident: &CStr = $name:expr;
+        const LOAD: bool = $load:expr; $(
         $(#[$meta:meta])*
         $vis:vis fn $symbol:ident($($argname:ident: $argtype:ty),*) -> $rettype:ty $fallback_body:block
     )*) => (
@@ -160,14 +174,22 @@ macro_rules! compat_fn_with_fallback {
             static PTR: AtomicPtr<c_void> = AtomicPtr::new(load as *mut _);
 
             unsafe extern "system" fn load($($argname: $argtype),*) -> $rettype {
-                let func = load_from_module(Module::new($module));
+                let func = load_from_module(load_module($module));
                 func($($argname),*)
             }
 
+            fn load_module() -> Option<Module> {
+                if $load {
+                    Module::load($module)
+                } else {
+                    Module::get($module)
+                }
+            }
+
             fn load_from_module(module: Option<Module>) -> F {
                 unsafe {
                     static SYMBOL_NAME: &CStr = ansi_str!(sym $symbol);
-                    if let Some(f) = Module::new($crate::sys::compat::UNICOWS_MODULE_NAME)
+                    if let Some(f) = Module::get($crate::sys::compat::UNICOWS_MODULE_NAME)
                         .and_then(|m| m.proc_address(SYMBOL_NAME))
                         .or_else(|| module.and_then(|m| m.proc_address(SYMBOL_NAME)))
                     {
@@ -196,7 +218,7 @@ macro_rules! compat_fn_with_fallback {
                 }
 
                 // Otherwise, the function pointer should be resolved
-                let _ = load_from_module(Module::new($module));
+                let _ = load_from_module(load_module($module));
 
                 // After resolution, the function pointer will only point to `fallback` if
                 // the target function was not found
@@ -212,6 +234,19 @@ macro_rules! compat_fn_with_fallback {
         $(#[$meta])*
         $vis use $symbol::call as $symbol;
     )*)
+    (pub static $module:ident: &CStr = $name:expr; $(
+        $(#[$meta:meta])*
+        $vis:vis fn $symbol:ident($($argname:ident: $argtype:ty),*) -> $rettype:ty $fallback_body:block
+    )*) => (
+        compat_fn_with_fallback! {
+            pub static $module: &CStr = $name;
+            const LOAD: bool = false;
+        $(
+            $(#[$meta])*
+            $vis fn $symbol($($argname: $argtype),*) -> $rettype $fallback_body
+        )*
+        }
+    )
 }
 
 /// Optionally loaded functions.
@@ -257,7 +292,7 @@ pub(super) fn load_synch_functions() {
 
         // Try loading the library and all the required functions.
         // If any step fails, then they all fail.
-        let library = unsafe { Module::new(MODULE_NAME) }?;
+        let library = unsafe { Module::get(MODULE_NAME) }?;
         let wait_on_address = library.proc_address(WAIT_ON_ADDRESS)?;
         let wake_by_address_single = library.proc_address(WAKE_BY_ADDRESS_SINGLE)?;