runtime: stabilize goroutine hooks and GOROOT classifications

.github/workflows/goroot.yml

@@ -20,6 +20,7 @@ jobs:
     env:
       GOPROXY: https://proxy.golang.org,direct
       LLGO_GOROOT_HEARTBEAT_SECONDS: "60"
+      LLGO_GOROOT_GOMAXPROCS: "1"
       LLGO_GOROOT_VERBOSE: "1"
     strategy:
       fail-fast: false
@@ -123,7 +124,7 @@ jobs:
             echo '|---:|---:|---:|---:|---:|'
             echo "| $selected | $observed | $passed | $failed | $skipped |"
             echo
-            echo '_Passed means the runner classification succeeded; expected xfail/not-applicable failures and classified flakes are counted as Passed._'
+            echo '_Passed means the runner classification succeeded; expected xfail failures and classified not-applicable/flake outcomes are counted as Passed._'
             echo
             echo '**Failed case paths**'
             if [[ "$failed" -eq 0 ]]; then
@@ -211,7 +212,7 @@ jobs:
             write_row 'Linux · Go 1.26.5' linux/amd64 1.26.5 4
             write_row '**Linux total**' linux/amd64 '' 8
             echo
-            echo '_Passed means the runner classification succeeded; expected xfail/not-applicable failures and classified flakes are counted as Passed._'
+            echo '_Passed means the runner classification succeeded; expected xfail failures and classified not-applicable/flake outcomes are counted as Passed._'
             echo
             echo '### Failed case paths'
             if [[ -s "$failure_tsv" ]]; then

runtime/internal/lib/runtime/pprof_runtime_stub_llgo.go

@@ -94,7 +94,7 @@ func ThreadCreateProfile(p []StackRecord) (n int, ok bool) {
 }
 
 func NumGoroutine() int {
-	return 1
+	return llrt.NumGoroutine()
 }
 
 const funcForPCCacheSets = 1024

runtime/internal/lib/runtime/sync_runtime_llgo.go

@@ -2,48 +2,11 @@
 
 package runtime
 
-import (
-	_ "sync/atomic"
-	_ "unsafe"
-
-	psync "github.com/xgo-dev/llgo/runtime/internal/clite/pthread/sync"
-)
+import _ "unsafe"
 
 var poolCleanup func()
-var procPinOnce psync.Once
-var procPinMu psync.Mutex
-
-func initProcPinMu() {
-	procPinMu.Init(nil)
-}
 
 //go:linkname sync_runtime_registerPoolCleanup sync.runtime_registerPoolCleanup
 func sync_runtime_registerPoolCleanup(cleanup func()) {
 	poolCleanup = cleanup
 }
-
-//go:linkname sync_runtime_procPin sync.runtime_procPin
-func sync_runtime_procPin() int {
-	procPinOnce.Do(initProcPinMu)
-	procPinMu.Lock()
-	return 0
-}
-
-//go:linkname sync_runtime_procUnpin sync.runtime_procUnpin
-func sync_runtime_procUnpin() {
-	procPinMu.Unlock()
-}
-
-// sync/atomic.Value expects these package-local runtime hooks. On darwin and
-// linux, LLGo serializes every procPin region with one process-wide mutex
-// because it cannot pin an OS-thread goroutine to a Go P.
-//
-//go:linkname atomic_runtime_procPin sync/atomic.runtime_procPin
-func atomic_runtime_procPin() int {
-	return sync_runtime_procPin()
-}
-
-//go:linkname atomic_runtime_procUnpin sync/atomic.runtime_procUnpin
-func atomic_runtime_procUnpin() {
-	sync_runtime_procUnpin()
-}

runtime/internal/runtime/proc.go

@@ -214,3 +214,11 @@ func GMPForTesting() (goid, parentGoid uint64, mid int64, pid int32, gstatus, ps
 func GStateForTesting() (count uint64, mainExited bool) {
 	return gStateForTesting()
 }
+
+// NumGoroutine returns the number of live runtime contexts. Calling getg first
+// ensures that a lazily initialized main or foreign thread is included.
+func NumGoroutine() int {
+	getg()
+	count, _ := gStateForTesting()
+	return int(count)
+}

runtime/internal/runtime/procpin.go

@@ -0,0 +1,48 @@
+//go:build darwin || linux
+
+package runtime
+
+import (
+	_ "unsafe"
+
+	psync "github.com/xgo-dev/llgo/runtime/internal/clite/pthread/sync"
+)
+
+var procPinOnce psync.Once
+var procPinMu psync.Mutex
+
+func initProcPinMu() {
+	procPinMu.Init(nil)
+}
+
+// LLGo has no Go P to pin a goroutine to. Serialize procPin regions instead,
+// preserving the exclusion that sync.Pool and sync/atomic.Value require.
+func procPin() int {
+	procPinOnce.Do(initProcPinMu)
+	procPinMu.Lock()
+	return 0
+}
+
+func procUnpin() {
+	procPinMu.Unlock()
+}
+
+//go:linkname syncRuntimeProcPin sync.runtime_procPin
+func syncRuntimeProcPin() int {
+	return procPin()
+}
+
+//go:linkname syncRuntimeProcUnpin sync.runtime_procUnpin
+func syncRuntimeProcUnpin() {
+	procUnpin()
+}
+
+//go:linkname atomicRuntimeProcPin sync/atomic.runtime_procPin
+func atomicRuntimeProcPin() int {
+	return procPin()
+}
+
+//go:linkname atomicRuntimeProcUnpin sync/atomic.runtime_procUnpin
+func atomicRuntimeProcUnpin() {
+	procUnpin()
+}

test/go/runtime_g_state_test.go

@@ -78,3 +78,28 @@ func TestRuntimeGStateIsolation(t *testing.T) {
 		t.Fatalf("main goroutine recovered %v, want %q", recovered, "main panic")
 	}
 }
+
+func TestRuntimeNumGoroutineTracksWorkers(t *testing.T) {
+	const workerCount = 8
+	ready := make(chan struct{}, workerCount)
+	release := make(chan struct{})
+	done := make(chan struct{}, workerCount)
+	for range workerCount {
+		go func() {
+			ready <- struct{}{}
+			<-release
+			done <- struct{}{}
+		}()
+	}
+	for range workerCount {
+		<-ready
+	}
+	if got := runtime.NumGoroutine(); got < workerCount+1 {
+		t.Fatalf("NumGoroutine with %d blocked workers = %d, want at least %d", workerCount, got, workerCount+1)
+	}
+
+	close(release)
+	for range workerCount {
+		<-done
+	}
+}

test/goroot/README.md

@@ -23,7 +23,9 @@ behavior are classified separately through `notapplicable.yaml`, so the xfail
 count continues to represent remaining LLGo compatibility work. Only
 explicitly host-unsafe cases are skipped. Each not-applicable entry documents
 both the toolchain-specific mechanism under test and why the corresponding
-behavior is not an LLGo compatibility goal.
+behavior is not an LLGo compatibility goal. Not-applicable classification is
+global rather than version- or platform-specific, and both successful and
+failed execution are accepted; resource-guard failures remain fatal.
 
 Basic usage:
 

test/goroot/notapplicable.yaml

@@ -514,6 +514,9 @@ not_applicable:
     directive: run
     case: maymorestack.go
     reason: "not applicable: LLGo uses fixed native stacks, so gc's growable-stack maymorestack debug hook has no corresponding behavior; supporting this toolchain-specific behavior is not an LLGo compatibility goal"
+  - directive: run
+    case: stack.go
+    reason: "not applicable: this case recursively grows through 8,000 large frames to validate cmd/compile's stack-splitting implementation; LLGo maps each goroutine to a native OS thread with a fixed stack, so reproducing Go's growable-stack mechanism is not currently an LLGo compatibility goal"
   - version: go1.26
     directive: errorcheckandrundir
     case: intrinsic.go

test/goroot/runner_test.go

@@ -357,7 +357,7 @@ func TestGoRootRunCases(t *testing.T) {
 			}
 			switch {
 			case err == nil && notApply:
-				t.Fatalf("unexpected success for not-applicable case: %s", notApplyReason)
+				t.Logf("not-applicable case passed: %s", notApplyReason)
 			case err == nil && match:
 				t.Fatalf("unexpected success for xfail case: %s", reason)
 			case err == nil && flaky:
@@ -378,7 +378,8 @@ func TestGoRootRunCases(t *testing.T) {
 func writeStdlibImportCfg(t *testing.T, goCmd string) string {
 	t.Helper()
 	cmd := exec.Command(goCmd, "list", "-export", "-f", "{{if .Export}}packagefile {{.ImportPath}}={{.Export}}{{end}}", "std")
-	cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=")
+	cmd.Dir = t.TempDir()
+	cmd.Env = baselineGoEnv()
 	output, err := cmd.CombinedOutput()
 	if err != nil {
 		t.Fatalf("list stdlib exports with %s: %v\n%s", goCmd, err, output)
@@ -406,7 +407,7 @@ func repoRoot(t *testing.T) string {
 func loadToolchainEnv(t *testing.T, goCmd string) toolchainEnv {
 	t.Helper()
 	cmd := exec.Command(goCmd, "env", "-json", "GOOS", "GOARCH", "GOVERSION", "CGO_ENABLED")
-	cmd.Env = append(os.Environ(), "GOENV=off", "GOFLAGS=")
+	cmd.Env = baselineGoEnv()
 	var stdout bytes.Buffer
 	var stderr bytes.Buffer
 	cmd.Stdout = &stdout
@@ -786,6 +787,8 @@ func runnerEnv(repoRoot, goroot, gopath string, extra []string) []string {
 			env[i] = "GOENV=off"
 		case strings.HasPrefix(item, "GOFLAGS="):
 			env[i] = "GOFLAGS="
+		case strings.HasPrefix(item, "GOTOOLCHAIN="):
+			env[i] = "GOTOOLCHAIN=local"
 		case strings.HasPrefix(item, "LLGO_ROOT="):
 			env[i] = "LLGO_ROOT=" + repoRoot
 		case strings.HasPrefix(item, "GOPATH="):
@@ -803,6 +806,7 @@ func runnerEnv(repoRoot, goroot, gopath string, extra []string) []string {
 	env = appendIfMissing(env, "GOROOT="+goroot)
 	env = appendIfMissing(env, "GOENV=off")
 	env = appendIfMissing(env, "GOFLAGS=")
+	env = appendIfMissing(env, "GOTOOLCHAIN=local")
 	env = appendIfMissing(env, "LLGO_ROOT="+repoRoot)
 	env = appendIfMissing(env, "GOPATH="+gopath)
 	env = appendIfMissing(env, "GO111MODULE=off")
@@ -812,6 +816,13 @@ func runnerEnv(repoRoot, goroot, gopath string, extra []string) []string {
 	return env
 }
 
+func baselineGoEnv() []string {
+	env := append([]string{}, os.Environ()...)
+	env = upsertEnv(env, "GOENV=off")
+	env = upsertEnv(env, "GOFLAGS=")
+	return upsertEnv(env, "GOTOOLCHAIN=local")
+}
+
 func appendIfMissing(env []string, kv string) []string {
 	key := strings.SplitN(kv, "=", 2)[0] + "="
 	for _, item := range env {
@@ -2066,7 +2077,20 @@ func (cfg xfailConfig) Match(goVersion, platform string, tc testCase) (bool, str
 }
 
 func (cfg notApplicableConfig) Match(goVersion, platform string, tc testCase) (bool, string) {
-	return matchEntries(cfg.Entries, goVersion, platform, tc)
+	for _, entry := range cfg.Entries {
+		// Applicability is an LLGo design property, not an observation tied to
+		// one hosted platform or Go release. Keep accepting legacy selectors in
+		// the YAML, but intentionally do not use them when classifying a case.
+		if !matchEntry("", "", entry.Directive, entry.Case, goVersion, platform, tc) {
+			continue
+		}
+		reason := entry.Reason
+		if reason == "" {
+			reason = entry.Case
+		}
+		return true, reason
+	}
+	return false, ""
 }
 
 func (cfg xfailConfig) MatchFlaky(goVersion, platform string, tc testCase) (bool, string) {