feat(fspy): add no-std Windows module lookup

Co-authored-by: GPT-5 Codex <codex@openai.com>

Author: wan9chi

Cargo.lock

@@ -31,6 +31,9 @@ atoi = { version = "3.1.0", default-features = false }
 rustix = { workspace = true, features = ["runtime"] }
 syscalls = { workspace = true }
 
+[target.'cfg(windows)'.dependencies]
+windows-sys = { workspace = true, features = ["Win32_Foundation", "Win32_System_LibraryLoader"] }
+
 # Cross-validates the page-size probe against rustix's auxv-based answer.
 [target.'cfg(target_os = "linux")'.dev-dependencies]
 rustix = { workspace = true, features = ["param"] }

crates/fspy_nostd/Cargo.toml

@@ -2,7 +2,7 @@
 
 Low-level operations for fspy code that runs before a process runtime is ready or in a context where normal runtime code can deadlock.
 
-The current implementation supports Linux and macOS. The crate has no Windows backend yet.
+The current implementation supports Linux, macOS, and Windows.
 
 ## Execution contexts
 
@@ -58,3 +58,4 @@ Code that needs allocation uses an explicit allocator. [`fspy_nostd_alloc`](../f
 - `env`: allocation-free process argument and environment iteration.
 - `fs`: filesystem operations with caller-owned buffers.
 - `param`: page-size access.
+- `get_module_name`: allocation-free lookup of an already-loaded Windows module.

crates/fspy_nostd/README.md

@@ -2,6 +2,28 @@ use core::{
     ffi::c_char, iter::FusedIterator, marker::PhantomData, num::NonZeroUsize, ptr::NonNull, slice,
 };
 
+mod private {
+    pub trait Sealed {}
+
+    impl Sealed for u8 {}
+    impl Sealed for u16 {}
+}
+
+/// A code unit supported by [`CStr`].
+pub trait CStrUnit: private::Sealed + Copy + Eq {
+    /// The terminating code unit.
+    #[doc(hidden)]
+    const NUL: Self;
+}
+
+impl CStrUnit for u8 {
+    const NUL: Self = 0;
+}
+
+impl CStrUnit for u16 {
+    const NUL: Self = 0;
+}
+
 /// Marks a [`CStr`] whose length is not known.
 #[derive(Clone, Copy)]
 pub struct Thin {
@@ -14,50 +36,56 @@ pub struct Fat {
     len_with_nul: NonZeroUsize,
 }
 
-/// A borrowed NUL-terminated string.
+/// A borrowed NUL-terminated string of code units.
 ///
 /// [`CStr<'_, Thin>`] stores only the string pointer, while
 /// [`CStr<'_, Fat>`] also stores the length including the terminating NUL.
 #[derive(Clone, Copy)]
-pub struct CStr<'a, R> {
-    ptr: NonNull<c_char>,
+pub struct CStr<'a, R, U: CStrUnit = u8> {
+    ptr: NonNull<U>,
     repr: R,
-    lifetime: PhantomData<&'a c_char>,
+    lifetime: PhantomData<&'a U>,
 }
 
-/// An iterator over the non-NUL bytes of a thin C string.
+/// A borrowed NUL-terminated string of `u16` code units.
+pub type WideCStr<'a, R> = CStr<'a, R, u16>;
+
+/// An iterator over the non-NUL code units of a thin C string.
 #[derive(Clone)]
-pub struct Bytes<'a> {
-    ptr: NonNull<u8>,
-    lifetime: PhantomData<&'a u8>,
+pub struct Units<'a, U: CStrUnit> {
+    ptr: NonNull<U>,
+    lifetime: PhantomData<&'a U>,
 }
 
-impl Iterator for Bytes<'_> {
-    type Item = u8;
+impl<U: CStrUnit> Iterator for Units<'_, U> {
+    type Item = U;
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         // SAFETY: `ptr` starts within a valid C string and is advanced only
-        // after reading a non-NUL byte, so it remains readable and never moves
-        // beyond the terminating NUL.
+        // after reading a non-NUL code unit, so it remains readable and never
+        // moves beyond the terminating NUL.
         unsafe {
-            let byte = self.ptr.read();
-            if byte == 0 {
+            let unit = self.ptr.read();
+            if unit == U::NUL {
                 None
             } else {
                 self.ptr = self.ptr.add(1);
-                Some(byte)
+                Some(unit)
             }
         }
     }
 }
 
-impl FusedIterator for Bytes<'_> {}
+impl<U: CStrUnit> FusedIterator for Units<'_, U> {}
 
-impl<R> CStr<'_, R> {
-    /// Returns a pointer to the first byte of this C string.
+/// An iterator over the non-NUL bytes of a thin byte C string.
+pub type Bytes<'a> = Units<'a, u8>;
+
+impl<R, U: CStrUnit> CStr<'_, R, U> {
+    /// Returns a pointer to the first code unit of this C string.
     #[must_use]
-    pub const fn as_ptr(&self) -> *const c_char {
+    pub const fn as_units_ptr(&self) -> *const U {
         self.ptr.as_ptr()
     }
 
@@ -68,6 +96,22 @@ impl<R> CStr<'_, R> {
     }
 }
 
+impl<R> CStr<'_, R> {
+    /// Returns a pointer to the first byte of this C string.
+    #[must_use]
+    pub const fn as_ptr(&self) -> *const c_char {
+        self.ptr.as_ptr().cast()
+    }
+}
+
+impl<R> CStr<'_, R, u16> {
+    /// Returns a pointer to the first UTF-16 code unit of this C string.
+    #[must_use]
+    pub const fn as_ptr(&self) -> *const u16 {
+        self.ptr.as_ptr()
+    }
+}
+
 impl Fat {
     /// Returns the represented length, including the terminating NUL.
     #[must_use]
@@ -76,105 +120,168 @@ impl Fat {
     }
 }
 
-impl<'a> CStr<'a, Thin> {
-    /// Creates a thin C string view from a non-null pointer without finding
-    /// its length.
+impl<'a, U: CStrUnit> CStr<'a, Thin, U> {
+    /// Creates a thin C string view from a non-null code-unit pointer without
+    /// finding its length.
     ///
     /// # Safety
     ///
     /// `ptr` must point to an immutable NUL-terminated string that remains
     /// valid for the lifetime of the returned view.
     #[must_use]
-    pub const unsafe fn from_non_null(ptr: NonNull<c_char>) -> Self {
+    pub const unsafe fn from_units_non_null(ptr: NonNull<U>) -> Self {
         Self { ptr, repr: Thin { _private: () }, lifetime: PhantomData }
     }
 
-    /// Creates a thin C string view without finding its length.
+    /// Creates a thin C string view from a code-unit pointer without finding
+    /// its length.
     ///
     /// # Safety
     ///
     /// `ptr` must be non-null and point to an immutable NUL-terminated string
     /// that remains valid for the lifetime of the returned view.
     #[must_use]
-    pub const unsafe fn from_ptr(ptr: *const c_char) -> Self {
+    pub const unsafe fn from_units_ptr(ptr: *const U) -> Self {
         // SAFETY: the caller guarantees that `ptr` is non-null.
         let ptr = unsafe { NonNull::new_unchecked(ptr.cast_mut()) };
         // SAFETY: the caller guarantees the remaining C string invariants.
-        unsafe { Self::from_non_null(ptr) }
+        unsafe { Self::from_units_non_null(ptr) }
     }
 
-    /// Returns an iterator over the bytes before the terminating NUL.
+    /// Returns an iterator over the code units before the terminating NUL.
     #[inline]
     #[must_use]
-    pub const fn bytes(self) -> Bytes<'a> {
-        Bytes { ptr: self.ptr.cast(), lifetime: PhantomData }
+    pub const fn units(self) -> Units<'a, U> {
+        Units { ptr: self.ptr, lifetime: PhantomData }
     }
 
     /// Counts through the terminating NUL and returns a length-retaining view.
     #[inline]
     #[must_use]
-    pub fn count(self) -> CStr<'a, Fat> {
-        let count = self.bytes().count();
+    pub fn count(self) -> CStr<'a, Fat, U> {
+        let count = self.units().count();
 
         CStr {
             ptr: self.ptr,
             repr: Fat {
                 // SAFETY: adding the terminator makes the represented length
                 // nonzero, and a valid allocation cannot contain `usize::MAX`
-                // non-NUL bytes.
+                // non-NUL code units.
                 len_with_nul: unsafe { NonZeroUsize::new_unchecked(count + 1) },
             },
             lifetime: PhantomData,
         }
     }
 }
 
-impl<'a> CStr<'a, Fat> {
-    /// Creates a length-retaining C string from bytes without validation.
+impl<'a> CStr<'a, Thin> {
+    /// Creates a thin C string view from a non-null pointer without finding
+    /// its length.
     ///
     /// # Safety
     ///
-    /// `bytes` must end with exactly one NUL byte and contain no other NUL
-    /// bytes.
+    /// `ptr` must point to an immutable NUL-terminated string that remains
+    /// valid for the lifetime of the returned view.
     #[must_use]
-    pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &'a [u8]) -> Self {
+    pub const unsafe fn from_non_null(ptr: NonNull<c_char>) -> Self {
+        // SAFETY: the caller guarantees the C string invariants.
+        unsafe { Self::from_units_non_null(ptr.cast()) }
+    }
+
+    /// Creates a thin C string view without finding its length.
+    ///
+    /// # Safety
+    ///
+    /// `ptr` must be non-null and point to an immutable NUL-terminated string
+    /// that remains valid for the lifetime of the returned view.
+    #[must_use]
+    pub const unsafe fn from_ptr(ptr: *const c_char) -> Self {
+        // SAFETY: the caller guarantees that `ptr` is non-null.
+        let ptr = unsafe { NonNull::new_unchecked(ptr.cast_mut()) };
+        // SAFETY: the caller guarantees the remaining C string invariants.
+        unsafe { Self::from_non_null(ptr) }
+    }
+
+    /// Returns an iterator over the bytes before the terminating NUL.
+    #[inline]
+    #[must_use]
+    pub const fn bytes(self) -> Bytes<'a> {
+        self.units()
+    }
+}
+
+impl<'a, U: CStrUnit> CStr<'a, Fat, U> {
+    /// Creates a length-retaining C string from code units without validation.
+    ///
+    /// # Safety
+    ///
+    /// `units` must end with exactly one NUL code unit and contain no other
+    /// NUL code units.
+    #[must_use]
+    pub const unsafe fn from_units_with_nul_unchecked(units: &'a [U]) -> Self {
         Self {
             // SAFETY: a valid C string is nonempty, so its pointer is non-null.
-            ptr: unsafe { NonNull::new_unchecked(bytes.as_ptr().cast::<c_char>().cast_mut()) },
+            ptr: unsafe { NonNull::new_unchecked(units.as_ptr().cast_mut()) },
             repr: Fat {
                 // SAFETY: a valid C string contains at least its terminating NUL.
-                len_with_nul: unsafe { NonZeroUsize::new_unchecked(bytes.len()) },
+                len_with_nul: unsafe { NonZeroUsize::new_unchecked(units.len()) },
             },
             lifetime: PhantomData,
         }
     }
 
-    /// Returns the string's bytes without the terminating NUL.
+    /// Returns the string's code units without the terminating NUL.
     #[must_use]
-    pub const fn as_bytes(&self) -> &'a [u8] {
-        let bytes = self.as_bytes_with_nul();
-        bytes.split_at(bytes.len() - 1).0
+    pub const fn as_units(&self) -> &'a [U] {
+        let units = self.as_units_with_nul();
+        units.split_at(units.len() - 1).0
     }
 
-    /// Returns the string's bytes, including the terminating NUL.
+    /// Returns the string's code units, including the terminating NUL.
     #[must_use]
-    pub const fn as_bytes_with_nul(&self) -> &'a [u8] {
+    pub const fn as_units_with_nul(&self) -> &'a [U] {
         // SAFETY: this view carries the exact initialized C string length.
-        unsafe { slice::from_raw_parts(self.ptr.as_ptr().cast(), self.len_with_nul()) }
+        unsafe { slice::from_raw_parts(self.ptr.as_ptr(), self.len_with_nul()) }
     }
 
-    /// Returns the number of bytes including the terminating NUL.
+    /// Returns the number of code units including the terminating NUL.
     #[must_use]
     pub const fn len_with_nul(&self) -> usize {
         self.repr.len_with_nul()
     }
 }
 
+impl<'a> CStr<'a, Fat> {
+    /// Creates a length-retaining C string from bytes without validation.
+    ///
+    /// # Safety
+    ///
+    /// `bytes` must end with exactly one NUL byte and contain no other NUL
+    /// bytes.
+    #[must_use]
+    pub const unsafe fn from_bytes_with_nul_unchecked(bytes: &'a [u8]) -> Self {
+        // SAFETY: the caller guarantees the generic C string invariants.
+        unsafe { Self::from_units_with_nul_unchecked(bytes) }
+    }
+
+    /// Returns the string's bytes without the terminating NUL.
+    #[must_use]
+    pub const fn as_bytes(&self) -> &'a [u8] {
+        self.as_units()
+    }
+
+    /// Returns the string's bytes, including the terminating NUL.
+    #[must_use]
+    pub const fn as_bytes_with_nul(&self) -> &'a [u8] {
+        self.as_units_with_nul()
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use core::{mem::size_of, ptr::NonNull};
 
-    use super::{CStr, Fat, Thin};
+    use super::{CStr, Fat, Thin, WideCStr};
 
     #[test]
     fn representations_retain_the_expected_metadata() {
@@ -185,6 +292,8 @@ mod tests {
 
         assert_eq!(size_of::<CStr<'_, Thin>>(), size_of::<*const u8>());
         assert_eq!(size_of::<CStr<'_, Fat>>(), size_of::<(*const u8, usize)>());
+        assert_eq!(size_of::<WideCStr<'_, Thin>>(), size_of::<*const u16>());
+        assert_eq!(size_of::<WideCStr<'_, Fat>>(), size_of::<(*const u16, usize)>());
         assert_eq!(fat.len_with_nul(), 4);
         assert_eq!(fat.as_bytes(), b"abc");
         assert_eq!(fat.as_bytes_with_nul(), b"abc\0");
@@ -212,4 +321,18 @@ mod tests {
         assert_eq!(bytes.next(), None);
         assert_eq!(bytes.next(), None);
     }
+
+    #[test]
+    fn wide_strings_iterate_and_retain_code_unit_lengths() {
+        let units = [u16::from(b'a'), u16::from(b'b'), 0];
+        // SAFETY: the input contains one trailing NUL.
+        let fat = unsafe { WideCStr::<Fat>::from_units_with_nul_unchecked(&units) };
+        // SAFETY: the same input is immutable and NUL-terminated.
+        let thin = unsafe { WideCStr::<Thin>::from_units_ptr(units.as_ptr()) };
+
+        assert!(thin.units().eq([u16::from(b'a'), u16::from(b'b')]));
+        assert_eq!(thin.count().as_units_with_nul(), units);
+        assert_eq!(fat.as_units(), [u16::from(b'a'), u16::from(b'b')]);
+        assert_eq!(fat.len_with_nul(), 3);
+    }
 }