cmd/cgo: use -Wl,--no-gc-sections if available

zig cc passes `--gc-sections` to the underlying linker, which then
causes undefined symbol errors when compiling with cgo but without C
code. Add `-Wl,--no-gc-sections` to make it work with zig cc. Minimal
example:

**main.go**

    package main
    import _ "runtime/cgo"
    func main() {}

Run (works after the patch, doesn't work before):

    CC="zig cc" go build main.go

Among the existing code, `src/runtime/testdata/testprognet` fails to
build:

    src/runtime/testdata/testprognet$ CC="zig cc" go build .
    net(.text): relocation target __errno_location not defined
    net(.text): relocation target getaddrinfo not defined
    net(.text): relocation target freeaddrinfo not defined
    net(.text): relocation target gai_strerror not defined
    runtime/cgo(.text): relocation target stderr not defined
    runtime/cgo(.text): relocation target fwrite not defined
    runtime/cgo(.text): relocation target vfprintf not defined
    runtime/cgo(.text): relocation target fputc not defined
    runtime/cgo(.text): relocation target abort not defined
    runtime/cgo(.text): relocation target pthread_create not defined
    runtime/cgo(.text): relocation target nanosleep not defined
    runtime/cgo(.text): relocation target pthread_detach not defined
    runtime/cgo(.text): relocation target stderr not defined
    runtime/cgo(.text): relocation target strerror not defined
    runtime/cgo(.text): relocation target fprintf not defined
    runtime/cgo(.text): relocation target abort not defined
    runtime/cgo(.text): relocation target pthread_mutex_lock not defined
    runtime/cgo(.text): relocation target pthread_cond_wait not defined
    runtime/cgo(.text): relocation target pthread_mutex_unlock not defined
    runtime/cgo(.text): relocation target pthread_cond_broadcast not defined
    runtime/cgo(.text): relocation target malloc not defined

With the patch both examples build as expected.

@ianlancetaylor suggested:

> It would be fine with me if somebody wants to send a cgo patch that
passes -Wl,--no-gc-sections, with a fallback if that option is not
supported.

... and this is what we are doing. Tested with zig
0.10.0-dev.2252+a4369918b

Fixes #52690

Author: motiejus

src/cmd/go/internal/work/exec.go

@@ -2342,7 +2342,7 @@ func (b *Builder) ccompile(a *Action, p *load.Package, outfile string, flags []s
 	// TODO(golang.org/issue/36072): cgo also generates files with #line
 	// directives pointing to the source directory. It should not generate those
 	// when -trimpath is enabled.
-	if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
+	if b.gccSupportsCompilerFlag(compiler, "-fdebug-prefix-map=a=b") {
 		if cfg.BuildTrimpath || p.Goroot {
 			// Keep in sync with Action.trimpath.
 			// The trimmed paths are a little different, but we need to trim in the
@@ -2520,19 +2520,26 @@ func (b *Builder) compilerCmd(compiler []string, incdir, workdir string) []strin
 	}
 
 	// disable ASCII art in clang errors, if possible
-	if b.gccSupportsFlag(compiler, "-fno-caret-diagnostics") {
+	if b.gccSupportsCompilerFlag(compiler, "-fno-caret-diagnostics") {
 		a = append(a, "-fno-caret-diagnostics")
 	}
 	// clang is too smart about command-line arguments
-	if b.gccSupportsFlag(compiler, "-Qunused-arguments") {
+	if b.gccSupportsCompilerFlag(compiler, "-Qunused-arguments") {
 		a = append(a, "-Qunused-arguments")
 	}
 
+	// zig cc passes --gc-sections to the underlying linker, which then causes
+	// undefined symbol errors when compiling with cgo but without C code.
+	// https://github.com/golang/go/issues/52690
+	if b.gccSupportsLinkerFlag(compiler, "-Wl,--no-gc-sections") {
+		a = append(a, "-Wl,--no-gc-sections")
+	}
+
 	// disable word wrapping in error messages
 	a = append(a, "-fmessage-length=0")
 
 	// Tell gcc not to include the work directory in object files.
-	if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
+	if b.gccSupportsCompilerFlag(compiler, "-fdebug-prefix-map=a=b") {
 		if workdir == "" {
 			workdir = b.WorkDir
 		}
@@ -2542,7 +2549,7 @@ func (b *Builder) compilerCmd(compiler []string, incdir, workdir string) []strin
 
 	// Tell gcc not to include flags in object files, which defeats the
 	// point of -fdebug-prefix-map above.
-	if b.gccSupportsFlag(compiler, "-gno-record-gcc-switches") {
+	if b.gccSupportsCompilerFlag(compiler, "-gno-record-gcc-switches") {
 		a = append(a, "-gno-record-gcc-switches")
 	}
 
@@ -2561,17 +2568,36 @@ func (b *Builder) compilerCmd(compiler []string, incdir, workdir string) []strin
 // -no-pie must be passed when doing a partial link with -Wl,-r.
 // But -no-pie is not supported by all compilers, and clang spells it -nopie.
 func (b *Builder) gccNoPie(linker []string) string {
-	if b.gccSupportsFlag(linker, "-no-pie") {
+	if b.gccSupportsCompilerFlag(linker, "-no-pie") {
 		return "-no-pie"
 	}
-	if b.gccSupportsFlag(linker, "-nopie") {
+	if b.gccSupportsCompilerFlag(linker, "-nopie") {
 		return "-nopie"
 	}
 	return ""
 }
 
-// gccSupportsFlag checks to see if the compiler supports a flag.
-func (b *Builder) gccSupportsFlag(compiler []string, flag string) bool {
+// gccSupportsCompilerFlag checks to see if the compiler supports a flag.
+// Does not apply to linker settings (-Wl,...)
+func (b *Builder) gccSupportsCompilerFlag(compiler []string, flag string) bool {
+	if strings.HasPrefix(flag, "-Wl,") {
+		base.Fatalf("use gccSupportsLinkerFlag for %q", flag)
+	}
+	return b.gccSupportsFlag(compiler, false, flag)
+}
+
+// gccSupportsLinkerFlag checks to see if compiler's linker supports a flag.
+// Flags need to be prefixed with `-Wl,<...>`.
+func (b *Builder) gccSupportsLinkerFlag(compiler []string, flag string) bool {
+	if !strings.HasPrefix(flag, "-Wl,") {
+		base.Fatalf("use gccSupportsCompilerFlag for %q", flag)
+	}
+	return b.gccSupportsFlag(compiler, true, flag)
+}
+
+// gccSupportsFlag should not be used; use gccSupportsCompilerFlag or
+// gccSupportsLinkerFlag
+func (b *Builder) gccSupportsFlag(compiler []string, link bool, flag string) bool {
 	key := [2]string{compiler[0], flag}
 
 	b.exec.Lock()
@@ -2600,7 +2626,12 @@ func (b *Builder) gccSupportsFlag(compiler []string, flag string) bool {
 	// version of GCC, so some systems have frozen on it.
 	// Now we pass an empty file on stdin, which should work at least for
 	// GCC and clang.
-	cmdArgs := str.StringList(compiler, flag, "-c", "-x", "c", "-", "-o", tmp)
+	cmdArgs := str.StringList(compiler, flag)
+	if !link {
+		cmdArgs = append(cmdArgs, "-c")
+	}
+	cmdArgs = append(cmdArgs, "-x", "c", "-", "-o", tmp)
+
 	if cfg.BuildN || cfg.BuildX {
 		b.Showcmd(b.WorkDir, "%s || true", joinUnambiguously(cmdArgs))
 		if cfg.BuildN {
@@ -2792,7 +2823,7 @@ func (b *Builder) cgo(a *Action, cgoExe, objdir string, pcCFLAGS, pcLDFLAGS, cgo
 	}
 
 	if cfg.BuildToolchainName == "gccgo" {
-		if b.gccSupportsFlag([]string{BuildToolchain.compiler()}, "-fsplit-stack") {
+		if b.gccSupportsCompilerFlag([]string{BuildToolchain.compiler()}, "-fsplit-stack") {
 			cgoCFLAGS = append(cgoCFLAGS, "-fsplit-stack")
 		}
 		cgoflags = append(cgoflags, "-gccgo")

src/cmd/go/internal/work/gccgo.go

@@ -80,7 +80,7 @@ func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg,
 
 	args := str.StringList(tools.compiler(), "-c", gcargs, "-o", ofile, forcedGccgoflags)
 	if importcfg != nil {
-		if b.gccSupportsFlag(args[:1], "-fgo-importcfg=/dev/null") {
+		if b.gccSupportsCompilerFlag(args[:1], "-fgo-importcfg=/dev/null") {
 			if err := b.writeFile(objdir+"importcfg", importcfg); err != nil {
 				return "", nil, err
 			}
@@ -93,14 +93,14 @@ func (tools gccgoToolchain) gc(b *Builder, a *Action, archive string, importcfg,
 			args = append(args, "-I", root)
 		}
 	}
-	if embedcfg != nil && b.gccSupportsFlag(args[:1], "-fgo-embedcfg=/dev/null") {
+	if embedcfg != nil && b.gccSupportsCompilerFlag(args[:1], "-fgo-embedcfg=/dev/null") {
 		if err := b.writeFile(objdir+"embedcfg", embedcfg); err != nil {
 			return "", nil, err
 		}
 		args = append(args, "-fgo-embedcfg="+objdir+"embedcfg")
 	}
 
-	if b.gccSupportsFlag(args[:1], "-ffile-prefix-map=a=b") {
+	if b.gccSupportsCompilerFlag(args[:1], "-ffile-prefix-map=a=b") {
 		if cfg.BuildTrimpath {
 			args = append(args, "-ffile-prefix-map="+base.Cwd()+"=.")
 			args = append(args, "-ffile-prefix-map="+b.WorkDir+"=/tmp/go-build")
@@ -567,17 +567,17 @@ func (tools gccgoToolchain) cc(b *Builder, a *Action, ofile, cfile string) error
 		defs = append(defs, `-D`, `GOPKGPATH="`+pkgpath+`"`)
 	}
 	compiler := envList("CC", cfg.DefaultCC(cfg.Goos, cfg.Goarch))
-	if b.gccSupportsFlag(compiler, "-fsplit-stack") {
+	if b.gccSupportsCompilerFlag(compiler, "-fsplit-stack") {
 		defs = append(defs, "-fsplit-stack")
 	}
 	defs = tools.maybePIC(defs)
-	if b.gccSupportsFlag(compiler, "-ffile-prefix-map=a=b") {
+	if b.gccSupportsCompilerFlag(compiler, "-ffile-prefix-map=a=b") {
 		defs = append(defs, "-ffile-prefix-map="+base.Cwd()+"=.")
 		defs = append(defs, "-ffile-prefix-map="+b.WorkDir+"=/tmp/go-build")
-	} else if b.gccSupportsFlag(compiler, "-fdebug-prefix-map=a=b") {
+	} else if b.gccSupportsCompilerFlag(compiler, "-fdebug-prefix-map=a=b") {
 		defs = append(defs, "-fdebug-prefix-map="+b.WorkDir+"=/tmp/go-build")
 	}
-	if b.gccSupportsFlag(compiler, "-gno-record-gcc-switches") {
+	if b.gccSupportsCompilerFlag(compiler, "-gno-record-gcc-switches") {
 		defs = append(defs, "-gno-record-gcc-switches")
 	}
 	return b.run(a, p.Dir, p.ImportPath, nil, compiler, "-Wall", "-g",