chore: add test to ensure dlls are lazily loaded on windows (#32648)

Author: dsherret

ext/webgpu/lib.rs

@@ -45,13 +45,22 @@ pub const UNSTABLE_FEATURE_NAME: &str = "webgpu";
 #[allow(clippy::print_stdout)]
 pub fn print_linker_flags(name: &str) {
   if cfg!(windows) {
-    // these dls load slowly, so delay loading them
+    // these dlls load slowly, so delay loading them
     let dlls = [
       // webgpu
       "d3dcompiler_47",
       "OPENGL32",
+      "gdi32",
+      "setupapi",
+      "oleaut32",
+      "combase",
       // network related functions
       "iphlpapi",
+      // timer functions
+      "winmm",
+      // debugging/diagnostics (only needed on panic/crash)
+      "dbghelp",
+      "psapi",
     ];
     for dll in dlls {
       println!("cargo:rustc-link-arg-bin={name}=/delayload:{dll}.dll");

tests/specs/build/windows_delay_loaded_dlls/__test__.jsonc

@@ -0,0 +1,5 @@
+{
+  "if": "windows",
+  "args": "run --allow-read check_dlls.ts",
+  "output": "output.out"
+}

tests/specs/build/windows_delay_loaded_dlls/check_dlls.ts

@@ -0,0 +1,121 @@
+// reads the deno binary's PE headers and outputs all DLLs
+// along with whether they are eagerly or delay-loaded.
+
+function readU16(buf: Uint8Array, offset: number): number {
+  return buf[offset] | (buf[offset + 1] << 8);
+}
+
+function readU32(buf: Uint8Array, offset: number): number {
+  return (
+    (buf[offset] |
+      (buf[offset + 1] << 8) |
+      (buf[offset + 2] << 16) |
+      ((buf[offset + 3] << 24) >>> 0)) >>>
+    0
+  );
+}
+
+function readCString(buf: Uint8Array, offset: number): string {
+  let end = offset;
+  while (end < buf.length && buf[end] !== 0) end++;
+  return new TextDecoder().decode(buf.subarray(offset, end));
+}
+
+interface Section {
+  name: string;
+  virtualAddress: number;
+  virtualSize: number;
+  rawOffset: number;
+  rawSize: number;
+}
+
+function rvaToOffset(rva: number, sections: Section[]): number | null {
+  for (const s of sections) {
+    if (rva >= s.virtualAddress && rva < s.virtualAddress + s.rawSize) {
+      return s.rawOffset + (rva - s.virtualAddress);
+    }
+  }
+  return null;
+}
+
+function parseDllNames(
+  buf: Uint8Array,
+  tableRva: number,
+  sections: Section[],
+  entrySize: number,
+  nameRvaOffset: number,
+): string[] {
+  const names: string[] = [];
+  const tableOffset = rvaToOffset(tableRva, sections);
+  if (tableOffset === null) return names;
+
+  let idx = 0;
+  while (true) {
+    const entryOff = tableOffset + idx * entrySize;
+    const nameRva = readU32(buf, entryOff + nameRvaOffset);
+    if (nameRva === 0) break;
+    const nameOff = rvaToOffset(nameRva, sections);
+    if (nameOff !== null) {
+      names.push(readCString(buf, nameOff).toLowerCase());
+    }
+    idx++;
+  }
+  return names;
+}
+
+const exePath = Deno.execPath();
+const buf = Deno.readFileSync(exePath);
+
+// parse PE
+const peOffset = readU32(buf, 0x3c);
+const numSections = readU16(buf, peOffset + 6);
+const sizeOptHeader = readU16(buf, peOffset + 24 - 4);
+const optStart = peOffset + 24;
+const magic = readU16(buf, optStart);
+
+if (magic !== 0x20b) {
+  console.error("not a PE32+ binary");
+  Deno.exit(1);
+}
+
+// data directories start at optStart + 112, preceded by count at +108
+const ddStart = optStart + 112;
+
+// read sections
+const secStart = optStart + sizeOptHeader;
+const sections: Section[] = [];
+for (let i = 0; i < numSections; i++) {
+  const off = secStart + i * 40;
+  let nameEnd = 8;
+  while (nameEnd > 0 && buf[off + nameEnd - 1] === 0) nameEnd--;
+  const name = new TextDecoder().decode(buf.subarray(off, off + nameEnd));
+  sections.push({
+    name,
+    virtualSize: readU32(buf, off + 8),
+    virtualAddress: readU32(buf, off + 12),
+    rawSize: readU32(buf, off + 16),
+    rawOffset: readU32(buf, off + 20),
+  });
+}
+
+// import directory (index 1) - entries are 20 bytes, name RVA at offset 12
+const importRva = readU32(buf, ddStart + 1 * 8);
+const eagerDlls = parseDllNames(buf, importRva, sections, 20, 12);
+
+// delay import directory (index 13) - entries are 32 bytes, name RVA at offset 4
+const delayRva = readU32(buf, ddStart + 13 * 8);
+const delayDlls = parseDllNames(buf, delayRva, sections, 32, 4);
+
+// deduplicate and collect all dlls with their load type
+const allDlls = new Map<string, string>();
+for (const dll of eagerDlls) {
+  allDlls.set(dll, "eager");
+}
+for (const dll of delayDlls) {
+  allDlls.set(dll, "delay");
+}
+
+const sorted = [...allDlls.entries()].sort((a, b) => a[0].localeCompare(b[0]));
+for (const [dll, type] of sorted) {
+  console.log(`${dll}: ${type}`);
+}

tests/specs/build/windows_delay_loaded_dlls/output.out

@@ -0,0 +1,21 @@
+[# this test is to ensure dlls don't negatively impact windows startup perf. Prefer lazily loading]
+advapi32.dll: eager
+api-ms-win-core-synch-l1-2-0.dll: eager
+bcrypt.dll: eager
+bcryptprimitives.dll: eager
+combase.dll: delay
+crypt32.dll: eager
+dbghelp.dll: delay
+gdi32.dll: delay
+iphlpapi.dll: delay
+kernel32.dll: eager
+ntdll.dll: eager
+oleaut32.dll: delay
+opengl32.dll: delay
+psapi.dll: delay
+setupapi.dll: delay
+shell32.dll: eager
+user32.dll: eager
+userenv.dll: eager
+winmm.dll: delay
+ws2_32.dll: eager