windows: integrate OS and standard-library support (R6, depends on xgo-dev/llgo#2405)

.gitattributes

@@ -0,0 +1,4 @@
+**/expect.txt text eol=lf
+**/out.txt text eol=lf
+*.ll text eol=lf
+_demo/go/export/libexport.h.want text eol=lf

.github/actions/setup-deps/action.yml

@@ -80,7 +80,9 @@ runs:
           "${urls[@]}"
         pacman --noconfirm -S --needed \
           --assume-installed "$assumed_cc_runtime" \
-          "$prefix-pkgconf"
+          "$prefix-pkgconf" \
+          "$prefix-sqlite3" \
+          make
 
         for package in clang clang-libs compiler-rt llvm llvm-libs lld libc++ libunwind; do
           installed="$(pacman -Q "$prefix-$package" | awk '{print $2}')"

.github/workflows/windows.yml

@@ -15,6 +15,22 @@ concurrency:
   cancel-in-progress: true
 
 jobs:
+  std-cover:
+    name: standard-library coverage (windows-amd64, Go 1.26.7)
+    runs-on: windows-2022
+    timeout-minutes: 30
+    steps:
+      - uses: actions/checkout@v7
+
+      - name: Set up Go
+        uses: ./.github/actions/setup-go
+        with:
+          go-version: "1.26.7"
+
+      - name: Check Windows standard-library coverage
+        shell: bash
+        run: bash doc/_readme/scripts/check_std_cover.sh
+
   native-compiler:
     name: native PE/COFF (windows-amd64, LLVM 19, Go 1.26.7)
     runs-on: windows-2022
@@ -198,6 +214,12 @@ jobs:
             -o ..\windows-runtime-smoke.exe `
             .\_test\windowsruntime
           $buildExitCode = $LASTEXITCODE
+          if ($buildExitCode -eq 0) {
+            ..\llgo-windows-smoke.exe build -tags=nogc `
+              -o ..\windows-stdlib-smoke.exe `
+              .\_test\windowsstdlib
+            $buildExitCode = $LASTEXITCODE
+          }
           if ($buildExitCode -eq 0) {
             ..\llgo-windows-smoke.exe build `
               -o ..\windows-ffi-smoke.exe `
@@ -221,6 +243,12 @@ jobs:
               .\_test\windowscorefault
             $buildExitCode = $LASTEXITCODE
           }
+          if ($buildExitCode -eq 0) {
+            ..\llgo-windows-smoke.exe build `
+              -o ..\windows-network-smoke.exe `
+              .\_test\windowsnetwork
+            $buildExitCode = $LASTEXITCODE
+          }
           Pop-Location
           if ($buildExitCode -ne 0) {
             exit $buildExitCode
@@ -230,15 +258,16 @@ jobs:
             -ReadObj $readObjExe `
             -Artifacts @(
               ".\windows-runtime-smoke.exe",
+              ".\windows-stdlib-smoke.exe",
               ".\windows-ffi-smoke.exe",
               ".\windows-empty-smoke.exe",
-              ".\windows-core-fault-smoke.exe"
+              ".\windows-core-fault-smoke.exe",
+              ".\windows-network-smoke.exe"
             )
           .\windows-runtime-smoke.exe
           if ($LASTEXITCODE -ne 0) {
             exit $LASTEXITCODE
           }
-
           $env:LLGO_TEST_UNRECOVERED_FAULT = "1"
           # This process is expected to write a panic to stderr and fail.
           # Temporarily keep native stderr non-terminating so it can be
@@ -253,6 +282,7 @@ jobs:
           }
           Remove-Item Env:LLGO_TEST_UNRECOVERED_FAULT
           Write-Host $faultOutput
+          $normalizedFaultOutput = $faultOutput.Replace('\', '/')
           if ($faultExitCode -eq 0) {
             throw "unrecovered Windows fault exited successfully"
           }
@@ -261,13 +291,26 @@ jobs:
             "main.windowsNilFault",
             "windowsruntime/main.go"
           )) {
-            if (-not $faultOutput.Contains($expected)) {
+            if (-not $normalizedFaultOutput.Contains($expected)) {
               throw "unrecovered Windows fault output is missing '$expected'"
             }
           }
           if ($faultOutput.Contains("github.com/xgo-dev/llgo/runtime/internal/clite/tls.init")) {
             throw "unrecovered Windows fault traceback continued past runtime.goexit"
           }
+          .\windows-stdlib-smoke.exe
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
+
+          $env:LLGO_TEST_OS_EXIT = "1"
+          .\windows-stdlib-smoke.exe
+          $exitCode = $LASTEXITCODE
+          Remove-Item Env:LLGO_TEST_OS_EXIT
+          if ($exitCode -ne 23) {
+            throw "os.Exit(23) returned exit code $exitCode"
+          }
+
           .\windows-ffi-smoke.exe
           if ($LASTEXITCODE -ne 0) {
             exit $LASTEXITCODE
@@ -280,3 +323,24 @@ jobs:
           if ($LASTEXITCODE -ne 0) {
             exit $LASTEXITCODE
           }
+          .\windows-network-smoke.exe
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }
+
+          # Exercise cmd/llgo's test path with testing-package behavior, cgo
+          # errno propagation, synchronization stress, CPU profiling, and
+          # runtime trace clock hooks.
+          # The runtime/FFI binaries above only cover build/run.
+          .\llgo-windows-smoke.exe test `
+            -p=1 `
+            -count=1 `
+            -timeout=10m `
+            ./test/windows `
+            ./test/cgo `
+            ./test/std/sync `
+            ./test/std/runtime/pprof `
+            ./test/std/runtime/trace
+          if ($LASTEXITCODE -ne 0) {
+            exit $LASTEXITCODE
+          }

_demo/go/createtemp-1654/main.go

@@ -6,9 +6,10 @@ import (
 	"sync"
 )
 
-// Regression stress for darwin/amd64 create-temp failure path.
-// If open failure does not return EEXIST correctly, os.CreateTemp may return
-// a file with an invalid fd and later operations can fail with EBADF.
+// Regression stress for concurrent temporary-file creation. It originally
+// covered the darwin/amd64 open-failure path, where losing EEXIST could leave
+// os.CreateTemp with an invalid fd. On Windows it also verifies that native
+// threads do not repeat one random-name sequence and continually collide.
 const (
 	goroutines = 4
 	iterations = 5000

_demo/go/export/use/main.c

@@ -4,6 +4,9 @@
 #include <assert.h>
 #include <errno.h>
 #include <string.h>
+#ifdef _WIN32
+#include <windows.h>
+#endif
 #include "../libexport.h"
 
 static int go_string_equals(GoString got, const char *want) {
@@ -31,6 +34,59 @@ static void void_callback(void) {
     void_callback_count++;
 }
 
+#ifdef _WIN32
+static volatile LONG foreign_fault_count;
+
+static LONG CALLBACK continue_foreign_fault(EXCEPTION_POINTERS *exception) {
+    EXCEPTION_RECORD *record = exception->ExceptionRecord;
+    if (record->ExceptionCode == EXCEPTION_ACCESS_VIOLATION &&
+        record->NumberParameters >= 2 && record->ExceptionInformation[1] == 0) {
+        InterlockedIncrement(&foreign_fault_count);
+        return EXCEPTION_CONTINUE_EXECUTION;
+    }
+    return EXCEPTION_CONTINUE_SEARCH;
+}
+
+static DWORD WINAPI call_go_export_from_foreign_thread(LPVOID arg) {
+    intptr_t value = (intptr_t)arg;
+    ULONG_PTR fault_information[2] = {0, 0};
+    // The LLGo DLL installs a process-wide vectored exception handler. A
+    // fault on a thread that has not entered Go must continue to the next
+    // native handler instead of being converted into a Go panic.
+    RaiseException(EXCEPTION_ACCESS_VIOLATION, 0, 2, fault_information);
+    for (int i = 0; i < 32; i++) {
+        GoString formatted = FormatValue((GoString){"thread", 6}, value + i);
+        if (formatted.n < 8 || memcmp(formatted.p, "thread:", 7) != 0) {
+            return 1;
+        }
+    }
+    return 0;
+}
+
+static void test_foreign_thread_exports(void) {
+    enum { thread_count = 8 };
+    HANDLE threads[thread_count];
+    PVOID fault_handler = AddVectoredExceptionHandler(0, continue_foreign_fault);
+    assert(fault_handler != NULL);
+    foreign_fault_count = 0;
+    for (intptr_t i = 0; i < thread_count; i++) {
+        threads[i] = CreateThread(NULL, 0, call_go_export_from_foreign_thread,
+                                  (LPVOID)i, 0, NULL);
+        assert(threads[i] != NULL);
+    }
+    assert(WaitForMultipleObjects(thread_count, threads, TRUE, INFINITE) ==
+           WAIT_OBJECT_0);
+    for (int i = 0; i < thread_count; i++) {
+        DWORD result;
+        assert(GetExitCodeThread(threads[i], &result));
+        assert(result == 0);
+        assert(CloseHandle(threads[i]));
+    }
+    assert(foreign_fault_count == thread_count);
+    assert(RemoveVectoredExceptionHandler(fault_handler));
+}
+#endif
+
 int main() {
     printf("=== C Export Demo ===\n");
     fflush(stdout);  // Force output
@@ -64,24 +120,27 @@ int main() {
     // that depend on the runtime hooks supplied by LLGo.
     GoString formatted = FormatValue((GoString){"answer", 6}, 42);
     assert(go_string_equals(formatted, "answer:42"));
+#ifdef _WIN32
+    test_foreign_thread_exports();
+#endif
 #ifdef __linux__
     assert(AllThreadsSyscallStatus() == ENOTSUP);
 #else
     assert(AllThreadsSyscallStatus() == 0);
 #endif
 
     // Test small struct
-    main_SmallStruct small = CreateSmallStruct(5, 1);  // 1 for true
-    assert(small.ID == 5);
-    assert(small.Flag == 1);
-    printf("Small struct: %d %d\n", small.ID, small.Flag);
+    main_SmallStruct small_value = CreateSmallStruct(5, 1);  // 1 for true
+    assert(small_value.ID == 5);
+    assert(small_value.Flag == 1);
+    printf("Small struct: %d %d\n", small_value.ID, small_value.Flag);
 
-    main_SmallStruct processed = ProcessSmallStruct(small);
+    main_SmallStruct processed = ProcessSmallStruct(small_value);
     assert(processed.ID == 6);
     assert(processed.Flag == 0);
     printf("Processed small: %d %d\n", processed.ID, processed.Flag);
 
-    main_SmallStruct* ptrSmall = ProcessSmallStructPtr(&small);
+    main_SmallStruct* ptrSmall = ProcessSmallStructPtr(&small_value);
     if (ptrSmall != NULL) {
         printf("Ptr small: %d %d\n", ptrSmall->ID, ptrSmall->Flag);
     }
@@ -140,13 +199,13 @@ int main() {
     printf("Uint64: %" PRIu64 "\n", ProcessUint64(10));
 
     assert(ProcessInt(10) == 110);  // ProcessInt(x) returns x * 11
-    printf("Int: %ld\n", ProcessInt(10));
+    printf("Int: %" PRIdPTR "\n", ProcessInt(10));
 
     assert(ProcessUint(10) == 210);  // ProcessUint(x) returns x * 21
-    printf("Uint: %lu\n", ProcessUint(10));
+    printf("Uint: %" PRIuPTR "\n", ProcessUint(10));
 
     assert(ProcessUintptr(0x1000) == 4396);  // ProcessUintptr(x) returns x + 300 = 4096 + 300
-    printf("Uintptr: %lu\n", ProcessUintptr(0x1000));
+    printf("Uintptr: %" PRIuPTR "\n", ProcessUintptr(0x1000));
 
     // Float comparisons with tolerance
     float f32_result = ProcessFloat32(3.14f);
@@ -209,10 +268,10 @@ int main() {
 
     // Test various parameter counts
     assert(NoParams() == 42);  // NoParams() always returns 42
-    printf("NoParams: %ld\n", NoParams());
+    printf("NoParams: %" PRIdPTR "\n", NoParams());
 
     assert(OneParam(5) == 10);  // OneParam(x) returns x * 2
-    printf("OneParam: %ld\n", OneParam(5));
+    printf("OneParam: %" PRIdPTR "\n", OneParam(5));
 
     assert(ThreeParams(10, 2.5, 1) == 25.0);  // ThreeParams calculates result
     printf("ThreeParams: %f\n", ThreeParams(10, 2.5, 1));  // 1 for true

cl/_testdata/floatint/in.go

@@ -1,4 +1,4 @@
-// LITTEST: POST-ABI darwin/arm64 linux/amd64 linux/arm64
+// LITTEST: POST-ABI darwin/arm64 linux/amd64 linux/arm64 windows/amd64
 // NOTE: Assertions have been autogenerated by chore/litgen UTC_ARGS: --function=f32ToI32 --function=f32ToU32 --function=f64ToUintptr --check-globals=none
 package main
 
@@ -10,46 +10,46 @@ func f64ToUintptr(v float64) uintptr { return uintptr(v) }
 // CHECK-SAME: float %[[TMP0:[0-9]+]]){{.*}} {
 // CHECK-NEXT: _llgo_[[BB0:[0-9]+]]:
 // ARM64-NEXT:   %[[TMP1:[0-9]+]] = fcmp ole float %[[TMP0]], 0xC1E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp olt float %[[TMP0]], 0xC1E0000000000000
+// AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp olt float %[[TMP0]], 0xC1E0000000000000
 // CHECK-NEXT:   %[[TMP2:[0-9]+]] = fcmp oge float %[[TMP0]], 0x41E0000000000000
 // CHECK-NEXT:   %[[TMP3:[0-9]+]] = fcmp uno float %[[TMP0]], %[[TMP0]]
 // ARM64-NEXT:   %[[TMP4:[0-9]+]] = select i1 %[[TMP1]], float 0.000000e+00, float %[[TMP0]]
 // ARM64-NEXT:   %[[TMP5:[0-9]+]] = select i1 %[[TMP2]], float 0.000000e+00, float %[[TMP4]]
 // ARM64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP3]], float 0.000000e+00, float %[[TMP5]]
-// LINUX-AMD64-NEXT:   %[[TMP4:[0-9]+]] = or i1 %[[TMP1]], %[[TMP2]]
-// LINUX-AMD64-NEXT:   %[[TMP5:[0-9]+]] = or i1 %[[TMP4]], %[[TMP3]]
-// LINUX-AMD64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP5]], float 0.000000e+00, float %[[TMP0]]
+// AMD64-NEXT:   %[[TMP4:[0-9]+]] = or i1 %[[TMP1]], %[[TMP2]]
+// AMD64-NEXT:   %[[TMP5:[0-9]+]] = or i1 %[[TMP4]], %[[TMP3]]
+// AMD64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP5]], float 0.000000e+00, float %[[TMP0]]
 // CHECK-NEXT:   %[[TMP7:[0-9]+]] = fptosi float %[[TMP6]] to i32
 // ARM64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP1]], i32 -2147483648, i32 %[[TMP7]]
 // ARM64-NEXT:   %[[TMP9:[0-9]+]] = select i1 %[[TMP2]], i32 2147483647, i32 %[[TMP8]]
 // ARM64-NEXT:   %[[TMP10:[0-9]+]] = select i1 %[[TMP3]], i32 0, i32 %[[TMP9]]
 // ARM64-NEXT:   ret i32 %[[TMP10]]
-// LINUX-AMD64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP5]], i32 -2147483648, i32 %[[TMP7]]
-// LINUX-AMD64-NEXT:   ret i32 %[[TMP8]]
+// AMD64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP5]], i32 -2147483648, i32 %[[TMP7]]
+// AMD64-NEXT:   ret i32 %[[TMP8]]
 // CHECK-NEXT: }
 
 // CHECK-LABEL: define i32 @main.f32ToU32(
 // CHECK-SAME: float %[[TMP0:[0-9]+]]){{.*}} {
 // CHECK-NEXT: _llgo_[[BB0:[0-9]+]]:
 // ARM64-NEXT:   %[[TMP1:[0-9]+]] = fcmp ole float %[[TMP0]], 0xC3E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp olt float %[[TMP0]], 0xC3E0000000000000
+// AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp olt float %[[TMP0]], 0xC3E0000000000000
 // CHECK-NEXT:   %[[TMP2:[0-9]+]] = fcmp oge float %[[TMP0]], 0x43E0000000000000
 // CHECK-NEXT:   %[[TMP3:[0-9]+]] = fcmp uno float %[[TMP0]], %[[TMP0]]
 // ARM64-NEXT:   %[[TMP4:[0-9]+]] = select i1 %[[TMP1]], float 0.000000e+00, float %[[TMP0]]
 // ARM64-NEXT:   %[[TMP5:[0-9]+]] = select i1 %[[TMP2]], float 0.000000e+00, float %[[TMP4]]
 // ARM64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP3]], float 0.000000e+00, float %[[TMP5]]
-// LINUX-AMD64-NEXT:   %[[TMP4:[0-9]+]] = or i1 %[[TMP1]], %[[TMP2]]
-// LINUX-AMD64-NEXT:   %[[TMP5:[0-9]+]] = or i1 %[[TMP4]], %[[TMP3]]
-// LINUX-AMD64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP5]], float 0.000000e+00, float %[[TMP0]]
+// AMD64-NEXT:   %[[TMP4:[0-9]+]] = or i1 %[[TMP1]], %[[TMP2]]
+// AMD64-NEXT:   %[[TMP5:[0-9]+]] = or i1 %[[TMP4]], %[[TMP3]]
+// AMD64-NEXT:   %[[TMP6:[0-9]+]] = select i1 %[[TMP5]], float 0.000000e+00, float %[[TMP0]]
 // CHECK-NEXT:   %[[TMP7:[0-9]+]] = fptosi float %[[TMP6]] to i64
 // ARM64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP1]], i64 -9223372036854775808, i64 %[[TMP7]]
 // ARM64-NEXT:   %[[TMP9:[0-9]+]] = select i1 %[[TMP2]], i64 9223372036854775807, i64 %[[TMP8]]
 // ARM64-NEXT:   %[[TMP10:[0-9]+]] = select i1 %[[TMP3]], i64 0, i64 %[[TMP9]]
 // ARM64-NEXT:   %[[TMP11:[0-9]+]] = trunc i64 %[[TMP10]] to i32
 // ARM64-NEXT:   ret i32 %[[TMP11]]
-// LINUX-AMD64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP5]], i64 -9223372036854775808, i64 %[[TMP7]]
-// LINUX-AMD64-NEXT:   %[[TMP9:[0-9]+]] = trunc i64 %[[TMP8]] to i32
-// LINUX-AMD64-NEXT:   ret i32 %[[TMP9]]
+// AMD64-NEXT:   %[[TMP8:[0-9]+]] = select i1 %[[TMP5]], i64 -9223372036854775808, i64 %[[TMP7]]
+// AMD64-NEXT:   %[[TMP9:[0-9]+]] = trunc i64 %[[TMP8]] to i32
+// AMD64-NEXT:   ret i32 %[[TMP9]]
 // CHECK-NEXT: }
 
 // CHECK-LABEL: define i64 @main.f64ToUintptr(
@@ -66,18 +66,18 @@ func f64ToUintptr(v float64) uintptr { return uintptr(v) }
 // ARM64-NEXT:   %[[TMP9:[0-9]+]] = select i1 %[[TMP1]], i64 0, i64 %[[TMP8]]
 // ARM64-NEXT:   %[[TMP10:[0-9]+]] = select i1 %[[TMP3]], i64 0, i64 %[[TMP9]]
 // ARM64-NEXT:   ret i64 %[[TMP10]]
-// LINUX-AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp oge double %[[TMP0]], 0x43E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP2:[0-9]+]] = fsub double %[[TMP0]], 0x43E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP3:[0-9]+]] = select i1 %[[TMP1]], double %[[TMP2]], double %[[TMP0]]
-// LINUX-AMD64-NEXT:   %[[TMP4:[0-9]+]] = fcmp olt double %[[TMP3]], 0xC3E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP5:[0-9]+]] = fcmp oge double %[[TMP3]], 0x43E0000000000000
-// LINUX-AMD64-NEXT:   %[[TMP6:[0-9]+]] = fcmp uno double %[[TMP3]], %[[TMP3]]
-// LINUX-AMD64-NEXT:   %[[TMP7:[0-9]+]] = or i1 %[[TMP4]], %[[TMP5]]
-// LINUX-AMD64-NEXT:   %[[TMP8:[0-9]+]] = or i1 %[[TMP7]], %[[TMP6]]
-// LINUX-AMD64-NEXT:   %[[TMP9:[0-9]+]] = select i1 %[[TMP8]], double 0.000000e+00, double %[[TMP3]]
-// LINUX-AMD64-NEXT:   %[[TMP10:[0-9]+]] = fptosi double %[[TMP9]] to i64
-// LINUX-AMD64-NEXT:   %[[TMP11:[0-9]+]] = select i1 %[[TMP8]], i64 -9223372036854775808, i64 %[[TMP10]]
-// LINUX-AMD64-NEXT:   %[[TMP12:[0-9]+]] = select i1 %[[TMP1]], i64 -9223372036854775808, i64 0
-// LINUX-AMD64-NEXT:   %[[TMP13:[0-9]+]] = or i64 %[[TMP11]], %[[TMP12]]
-// LINUX-AMD64-NEXT:   ret i64 %[[TMP13]]
+// AMD64-NEXT:   %[[TMP1:[0-9]+]] = fcmp oge double %[[TMP0]], 0x43E0000000000000
+// AMD64-NEXT:   %[[TMP2:[0-9]+]] = fsub double %[[TMP0]], 0x43E0000000000000
+// AMD64-NEXT:   %[[TMP3:[0-9]+]] = select i1 %[[TMP1]], double %[[TMP2]], double %[[TMP0]]
+// AMD64-NEXT:   %[[TMP4:[0-9]+]] = fcmp olt double %[[TMP3]], 0xC3E0000000000000
+// AMD64-NEXT:   %[[TMP5:[0-9]+]] = fcmp oge double %[[TMP3]], 0x43E0000000000000
+// AMD64-NEXT:   %[[TMP6:[0-9]+]] = fcmp uno double %[[TMP3]], %[[TMP3]]
+// AMD64-NEXT:   %[[TMP7:[0-9]+]] = or i1 %[[TMP4]], %[[TMP5]]
+// AMD64-NEXT:   %[[TMP8:[0-9]+]] = or i1 %[[TMP7]], %[[TMP6]]
+// AMD64-NEXT:   %[[TMP9:[0-9]+]] = select i1 %[[TMP8]], double 0.000000e+00, double %[[TMP3]]
+// AMD64-NEXT:   %[[TMP10:[0-9]+]] = fptosi double %[[TMP9]] to i64
+// AMD64-NEXT:   %[[TMP11:[0-9]+]] = select i1 %[[TMP8]], i64 -9223372036854775808, i64 %[[TMP10]]
+// AMD64-NEXT:   %[[TMP12:[0-9]+]] = select i1 %[[TMP1]], i64 -9223372036854775808, i64 0
+// AMD64-NEXT:   %[[TMP13:[0-9]+]] = or i64 %[[TMP11]], %[[TMP12]]
+// AMD64-NEXT:   ret i64 %[[TMP13]]
 // CHECK-NEXT: }