Fix function pointer checks on Windows

Author: mansiverma897993

ctest/src/runner.rs

@@ -141,9 +141,15 @@ pub fn __compile_test(
 
     // Pass in a different target, linker or flags if set, useful for cross compilation.
 
-    let target = env::var("TARGET_PLATFORM").unwrap_or_default();
+    let target = env::var("TARGET_PLATFORM")
+        .or_else(|_| env::var("TARGET"))
+        .unwrap_or_default();
     if !target.is_empty() {
-        cmd.arg("--target").arg(target);
+        cmd.arg("--target").arg(&target);
+    }
+
+    if target.contains("windows") && target.contains("gnu") {
+        cmd.arg("-lws2_32");
     }
 
     let linker = env::var("LINKER").unwrap_or_default();

ctest/templates/test.c

@@ -89,7 +89,7 @@ CTEST_EXTERN uint64_t ctest_offset_of__{{ item.id }}__{{ item.field.ident() }}(v
 }
 
 CTEST_EXTERN uint64_t ctest_size_of__{{ item.id }}__{{ item.field.ident() }}(void) {
-    return sizeof((({{ item.c_ty }}){}).{{ item.c_field }});
+    return sizeof((({{ item.c_ty }} *)0)->{{ item.c_field }});
 }
 {%- endfor +%}
 

ctest/templates/test.rs

@@ -39,6 +39,47 @@ mod generated_tests {
         }
     }
 
+    fn check_same_fn_ptr(mut rust: u64, mut c: u64, attr: &str) {
+        if rust == c {
+            NTESTS.fetch_add(1, Ordering::Relaxed);
+            return;
+        }
+
+        #[cfg(target_os = "windows")]
+        unsafe {
+            let resolve = |addr: u64| -> u64 {
+                if addr == 0 {
+                    return 0;
+                }
+                #[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
+                {
+                    let bytes = addr as *const u8;
+                    if *bytes == 0xff && *bytes.add(1) == 0x25 {
+                        if cfg!(target_arch = "x86_64") {
+                            let displacement = (bytes.add(2) as *const i32).read_unaligned();
+                            let address_of_pointer = bytes.add(6).offset(displacement as isize) as *const *const ();
+                            return *address_of_pointer as u64;
+                        } else if cfg!(target_arch = "x86") {
+                            let address_of_pointer = (bytes.add(2) as *const *const *const ()).read_unaligned();
+                            return *address_of_pointer as u64;
+                        }
+                    }
+                }
+                addr
+            };
+
+            rust = resolve(rust);
+            c = resolve(c);
+        }
+
+        if rust != c {
+            eprintln!("bad {attr}: rust: {rust:?} != c {c:?}");
+            FAILED.store(true, Ordering::Relaxed);
+        } else {
+            NTESTS.fetch_add(1, Ordering::Relaxed);
+        }
+    }
+
     fn check_same_bytes(rust: &[u8], c: &[u8], attr: &str) {
         if rust == c {
             NTESTS.fetch_add(1, Ordering::Relaxed);
@@ -360,7 +401,7 @@ mod generated_tests {
         }
         let actual = unsafe { ctest_foreign_fn__{{ item.id }}() } as u64;
         let expected = {{ item.id }} as *const () as u64;
-        check_same(actual, expected, "`{{ item.id }}` function pointer");
+        check_same_fn_ptr(actual, expected, "`{{ item.id }}` function pointer");
     }
 {%- endfor +%}
 

libc-test/build.rs

@@ -847,8 +847,12 @@ fn test_windows(target: &str) {
     });
 
     cfg.skip_struct_field(move |s, field| s.ident() == "CONTEXT" && field.ident() == "Fp");
-    // FIXME(windows): All functions point to the wrong addresses?
-    cfg.skip_fn_ptrcheck(|_| true);
+    // FIXME(windows): ctime and difftime are inline functions on the C side,
+    // so their addresses resolve to local wrappers rather than the DLL exports.
+    cfg.skip_fn_ptrcheck(|name| match name {
+        "ctime" | "difftime" => true,
+        _ => false,
+    });
 
     cfg.skip_signededness(move |c| {
         match c {