feat(testrunner): //!-suppressions= directive for per-file valgrind silencers

Author: Azer0s

main.go

@@ -524,18 +524,23 @@ func expandShellExprs(s string) string {
 }
 
 // parseFileDirectives scans the leading lines of src for //! directives and
-// returns linker flags and C source files to compile in.
+// returns linker flags, C source files to compile in, and valgrind
+// suppression paths to apply when the test runs under --valgrind.
 //
 //	//!-lm                         -> linker flag -lm
 //	//!-lm [x86_64]                -> linker flag -lm, x86_64 only
 //	//!+helper.c                   -> compile helper.c alongside the module
 //	//!+src/foo.c -- -DDEBUG       -> compile src/foo.c with extra flag -DDEBUG
 //	//!+src/foo.c [arch]           -> compile only on matching arch
 //	//!+src/foo.c [arch] -- FLAGS  -> arch-specific file with extra flags
+//	//!-suppressions=PATH          -> pass --suppressions=PATH to valgrind
+//	                                   for this file (no effect outside --valgrind)
 //
-// srcDir is the directory of the .tin file; relative C source paths are
-// resolved against it. Scanning stops at the first non-comment, non-blank line.
-func parseFileDirectives(src, srcDir, stdlibDir string) (linkerFlags []string, cSources []cSource) {
+// srcDir is the directory of the .tin file; relative paths are resolved
+// against it.  $TIN_RUNTIME / $TIN_STDLIB / $ENV variables expand in
+// suppression paths the same way they do in //!+file flags.  Scanning
+// stops at the first non-comment, non-blank line.
+func parseFileDirectives(src, srcDir, stdlibDir string) (linkerFlags []string, cSources []cSource, vgSuppressions []string) {
 	for _, line := range strings.SplitAfter(src, "\n") {
 		trimmed := strings.TrimSpace(line)
 		if trimmed == "" || strings.HasPrefix(trimmed, "//") && !strings.HasPrefix(trimmed, "//!") {
@@ -603,6 +608,27 @@ func parseFileDirectives(src, srcDir, stdlibDir string) (linkerFlags []string, c
 				}
 
 				cSources = append(cSources, cSource{path: cpath, flags: extraFlags})
+			} else if strings.HasPrefix(rest, "-suppressions=") {
+				// Valgrind-only directive: register a suppressions file
+				// that applies when the binary runs under --valgrind.
+				// Honours the same `[arch]` qualifier as the other
+				// directives so platform-specific suppressions stay
+				// scoped (e.g. a glibc-only file is skipped on macOS).
+				specAndQualifier, archQualifier := extractArchQualifier(strings.TrimPrefix(rest, "-suppressions="))
+				if !archMatches(archQualifier) {
+					continue
+				}
+
+				rtDir := tinRuntimeDir()
+				expanded := strings.ReplaceAll(specAndQualifier, "$TIN_RUNTIME", rtDir)
+				expanded = strings.ReplaceAll(expanded, "$TIN_STDLIB", stdlibDir)
+				expanded = os.ExpandEnv(expanded)
+
+				if !filepath.IsAbs(expanded) {
+					expanded = filepath.Join(srcDir, expanded)
+				}
+
+				vgSuppressions = append(vgSuppressions, expanded)
 			} else {
 				// Linker flag: check for optional arch qualifier.
 				flagAndQualifier, archQualifier := extractArchQualifier(rest)
@@ -995,7 +1021,10 @@ doneFlags:
 		if _, statErr := os.Stat(runCacheBinPath); statErr == nil && sbomMatches(runCacheDir) {
 			memcheck, binArgs := parseRunArgs(fileArgIdx)
 			validateMemcheck(memcheck)
-			execRunBinary(runCacheBinPath, memcheck, binArgs)
+			// Pick up `//!-suppressions=` from the source so cached
+			// single-file tests still hand them to valgrind.
+			_, _, vgSupps := parseFileDirectives(string(src), filepath.Dir(file), stdlibDirForDirectives(stdlibOverride))
+			execRunBinary(runCacheBinPath, memcheck, binArgs, vgSupps...)
 
 			return
 		}
@@ -1026,7 +1055,7 @@ doneFlags:
 	}
 
 	// Collect directives declared in the source file via //! lines
-	fileLinkerFlags, fileCSources := parseFileDirectives(string(src), filepath.Dir(file), stdlibDirForDirectives(stdlibOverride))
+	fileLinkerFlags, fileCSources, fileVgSuppressions := parseFileDirectives(string(src), filepath.Dir(file), stdlibDirForDirectives(stdlibOverride))
 
 	// Estimate total stages for progress display. Mirrors the actual
 	// step shape so the post-codegen setTotal call refines without
@@ -1238,7 +1267,7 @@ doneFlags:
 			continue
 		}
 
-		pkgLinkFlags, pkgCSources := parseFileDirectives(string(src), filepath.Dir(pkgSrc), stdlibDirForDirectives(stdlibOverride))
+		pkgLinkFlags, pkgCSources, _ := parseFileDirectives(string(src), filepath.Dir(pkgSrc), stdlibDirForDirectives(stdlibOverride))
 		fileLinkerFlags = append(fileLinkerFlags, pkgLinkFlags...)
 		fileCSources = append(fileCSources, pkgCSources...)
 	}
@@ -1437,7 +1466,7 @@ doneFlags:
 		cprog.clear()
 
 		validateMemcheck(memcheck)
-		execRunBinary(runCacheBinPath, memcheck, binArgs)
+		execRunBinary(runCacheBinPath, memcheck, binArgs, fileVgSuppressions...)
 
 	default:
 		_, _ = fmt.Fprint(os.Stderr, usage)
@@ -2668,16 +2697,30 @@ func validateMemcheck(memcheck string) {
 // foreign-arch binaries can be exercised on the host. Modeled on Go's GOEXEC
 // and Cargo's CARGO_TARGET_<TRIPLE>_RUNNER.
 func memcheckCmd(memcheck, binary string, binArgs ...string) *exec.Cmd {
+	return memcheckCmdWithSuppressions(memcheck, binary, nil, binArgs...)
+}
+
+// memcheckCmdWithSuppressions is memcheckCmd plus an explicit list of
+// valgrind --suppressions=PATH files.  The test runner gathers these
+// from `//!-suppressions=FILE` directives declared in the test source
+// so the silence stays scoped to the file that opted in -- a global
+// suppression set would silently hide leaks in unrelated tests.
+func memcheckCmdWithSuppressions(memcheck, binary string, vgSuppressions []string, binArgs ...string) *exec.Cmd {
 	switch memcheck {
 	case "valgrind":
-		args := append([]string{
+		vgArgs := []string{
 			"--error-exitcode=1",
 			"--leak-check=full",
 			"--errors-for-leak-kinds=all",
-			binary,
-		}, binArgs...)
+		}
+		for _, s := range vgSuppressions {
+			vgArgs = append(vgArgs, "--suppressions="+s)
+		}
+
+		vgArgs = append(vgArgs, binary)
+		vgArgs = append(vgArgs, binArgs...)
 
-		return wrapExec("valgrind", args...)
+		return wrapExec("valgrind", vgArgs...)
 	case "leaks":
 		args := append([]string{"--atExit", "--", binary}, binArgs...)
 
@@ -2851,6 +2894,12 @@ func runFileTests(fpaths []string, extraFlags []string, extraCFlags []string, me
 			continue
 		}
 
+		// Parse //!-suppressions= directives up front so both the
+		// cache-hit and the fresh-compile branches below can hand them
+		// to memcheckCmdWithSuppressions; valgrind picks them up,
+		// non-valgrind runs just ignore the list.
+		_, _, fileVgSuppressions := parseFileDirectives(string(src), filepath.Dir(fpath), stdlibDirForDirectives(""))
+
 		// Cache lookup: if the test binary is already built and every dep
 		// recorded in its SBOM still hashes the same, run the cached binary
 		// directly and skip lex/parse/codegen for this file.
@@ -2860,7 +2909,7 @@ func runFileTests(fpaths []string, extraFlags []string, extraCFlags []string, me
 		if _, statErr := os.Stat(cachedBin); statErr == nil && sbomMatches(cacheDir) {
 			fmt.Printf("%s\n\n", fname)
 
-			run := memcheckCmd(memcheck, cachedBin)
+			run := memcheckCmdWithSuppressions(memcheck, cachedBin, fileVgSuppressions)
 
 			var outBuf bytes.Buffer
 
@@ -2994,21 +3043,24 @@ func runFileTests(fpaths []string, extraFlags []string, extraCFlags []string, me
 			continue // no test blocks in this file
 		}
 
-		fileLinks, fCSources := parseFileDirectives(string(src), filepath.Dir(fpath), stdlibDirForDirectives(""))
+		fileLinks, fCSources, _ := parseFileDirectives(string(src), filepath.Dir(fpath), stdlibDirForDirectives(""))
 
 		srcLinks := append([]string{}, fileLinks...)
 		for _, lib := range cg.LinkLibs() {
 			srcLinks = append(srcLinks, "-l"+lib)
 		}
 		// Collect //!+file.c and //!-lNAME directives from imported packages,
-		// just as the single-file build path does.
+		// just as the single-file build path does.  --valgrind suppression
+		// directives stay scoped to the test file -- pulling them in from
+		// every transitive package would silence checks they didn't opt
+		// into.
 		for _, pkgSrc := range cg.PackageSrcPaths() {
 			pkgBytes, pkgReadErr := os.ReadFile(pkgSrc)
 			if pkgReadErr != nil {
 				continue
 			}
 
-			pkgLinks, pkgCSrcs := parseFileDirectives(string(pkgBytes), filepath.Dir(pkgSrc), stdlibDirForDirectives(""))
+			pkgLinks, pkgCSrcs, _ := parseFileDirectives(string(pkgBytes), filepath.Dir(pkgSrc), stdlibDirForDirectives(""))
 			srcLinks = append(srcLinks, pkgLinks...)
 			fCSources = append(fCSources, pkgCSrcs...)
 		}
@@ -3089,7 +3141,7 @@ func runFileTests(fpaths []string, extraFlags []string, extraCFlags []string, me
 		cprog.clear()
 		fmt.Printf("%s\n\n", fname)
 
-		run := memcheckCmd(memcheck, cachedBin)
+		run := memcheckCmdWithSuppressions(memcheck, cachedBin, fileVgSuppressions)
 
 		var outBuf bytes.Buffer
 
@@ -3623,8 +3675,8 @@ func collectExtraObjs(fileArgIdx int) []string {
 }
 
 // execRunBinary runs `bin` (under memcheck if set) and exits with its status.
-func execRunBinary(bin, memcheck string, binArgs []string) {
-	run := memcheckCmd(memcheck, bin, binArgs...)
+func execRunBinary(bin, memcheck string, binArgs []string, vgSuppressions ...string) {
+	run := memcheckCmdWithSuppressions(memcheck, bin, vgSuppressions, binArgs...)
 	run.Stdout = os.Stdout
 	run.Stderr = os.Stderr
 

stdlib/net/dns/dns_test.tin

@@ -1,8 +1,17 @@
+//!-suppressions=valgrind-glibc-nss.supp [linux]
 // stdlib/net/dns/dns_test.tin -- coverage for net::dns.
 //
 // lookup_host hits the real resolver, so we test against `localhost`
 // which every POSIX system resolves locally (127.0.0.1 and ::1) and
 // against a guaranteed-invalid label to exercise the error path.
+//
+// The `//!-suppressions=` directive above (linux-only) silences the 21
+// "still reachable" blocks glibc's lazy nss/resolver dlopen leaves
+// mapped for the process lifetime when getaddrinfo() runs for the
+// first time.  Pure-C reproducer with the exact same byte/block count
+// proves they originate entirely in glibc; the suppression rules in
+// the file are anchored at `_dl_open` so real leaks elsewhere are
+// not affected.
 
 use assert
 use net::dns

stdlib/net/dns/valgrind-glibc-nss.supp

@@ -0,0 +1,36 @@
+# runtime/valgrind-glibc-nss.supp -- valgrind suppressions for glibc's
+# lazy nss / resolver module loading.
+#
+# The first getaddrinfo() (and similar nss callers) in a glibc process
+# loads libnss_files.so / libnss_dns.so / libresolv.so via
+# __libc_dlopen_mode -> _dl_open and keeps the resulting mappings live
+# for the program's lifetime.  The rtld bookkeeping for those .so's
+# (linkmap entries, version maps, scope arrays, cache strdup'd paths)
+# stays in glibc's globals with no dlclose() ever called -- valgrind
+# reports each as "still reachable".
+#
+# Verified by a pure-C reproducer that calls only getaddrinfo() +
+# freeaddrinfo() with zero Tin code on the stack: 9,816 bytes / 21
+# blocks / 8 records, byte-for-byte identical to what Tin's dns_test
+# shows.  Every record's call chain terminates at `_dl_open` (the
+# dynamic linker's open-and-map entry), so we anchor the match there.
+# Real reachable leaks elsewhere in the program (no `_dl_open` frame
+# on the stack) still surface.
+
+{
+   glibc-rtld-dlopen-malloc-reachable
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:malloc
+   ...
+   fun:_dl_open
+}
+
+{
+   glibc-rtld-dlopen-calloc-reachable
+   Memcheck:Leak
+   match-leak-kinds: reachable
+   fun:calloc
+   ...
+   fun:_dl_open
+}