blob: a52457efccdc677eef69069095faba39e30e5dd1 [file] [log] [blame]
// Copyright 2015 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
package main
import (
"bytes"
"flag"
"fmt"
"io/fs"
"log"
"os"
"os/exec"
"path/filepath"
"reflect"
"regexp"
"runtime"
"strconv"
"strings"
"time"
)
func cmdtest() {
gogcflags = os.Getenv("GO_GCFLAGS")
setNoOpt()
var t tester
var noRebuild bool
flag.BoolVar(&t.listMode, "list", false, "list available tests")
flag.BoolVar(&t.rebuild, "rebuild", false, "rebuild everything first")
flag.BoolVar(&noRebuild, "no-rebuild", false, "overrides -rebuild (historical dreg)")
flag.BoolVar(&t.keepGoing, "k", false, "keep going even when error occurred")
flag.BoolVar(&t.race, "race", false, "run in race builder mode (different set of tests)")
flag.BoolVar(&t.compileOnly, "compile-only", false, "compile tests, but don't run them. This is for some builders. Not all dist tests respect this flag, but most do.")
flag.StringVar(&t.banner, "banner", "##### ", "banner prefix; blank means no section banners")
flag.StringVar(&t.runRxStr, "run", "",
"run only those tests matching the regular expression; empty means to run all. "+
"Special exception: if the string begins with '!', the match is inverted.")
flag.BoolVar(&t.msan, "msan", false, "run in memory sanitizer builder mode")
flag.BoolVar(&t.asan, "asan", false, "run in address sanitizer builder mode")
xflagparse(-1) // any number of args
if noRebuild {
t.rebuild = false
}
t.run()
}
// tester executes cmdtest.
type tester struct {
race bool
msan bool
asan bool
listMode bool
rebuild bool
failed bool
keepGoing bool
compileOnly bool // just try to compile all tests, but no need to run
runRxStr string
runRx *regexp.Regexp
runRxWant bool // want runRx to match (true) or not match (false)
runNames []string // tests to run, exclusive with runRx; empty means all
banner string // prefix, or "" for none
lastHeading string // last dir heading printed
short bool
cgoEnabled bool
partial bool
goExe string // For host tests
goTmpDir string // For host tests
tests []distTest
timeoutScale int
worklist []*work
}
type work struct {
dt *distTest
cmd *exec.Cmd
start chan bool
out []byte
err error
end chan bool
}
// A distTest is a test run by dist test.
// Each test has a unique name and belongs to a group (heading)
type distTest struct {
name string // unique test name; may be filtered with -run flag
heading string // group section; this header is printed before the test is run.
fn func(*distTest) error
}
func (t *tester) run() {
timelog("start", "dist test")
os.Setenv("PATH", fmt.Sprintf("%s%c%s", gorootBin, os.PathListSeparator, os.Getenv("PATH")))
t.short = true
if v := os.Getenv("GO_TEST_SHORT"); v != "" {
short, err := strconv.ParseBool(v)
if err != nil {
fatalf("invalid GO_TEST_SHORT %q: %v", v, err)
}
t.short = short
}
cmd := exec.Command(gorootBinGo, "env", "CGO_ENABLED", "GOEXE", "GOTMPDIR")
cmd.Stderr = new(bytes.Buffer)
slurp, err := cmd.Output()
if err != nil {
fatalf("Error running %s: %v\n%s", cmd, err, cmd.Stderr)
}
parts := strings.Split(string(slurp), "\n")
if len(parts) < 3 {
fatalf("Error running %s: output contains <3 lines\n%s", cmd, cmd.Stderr)
}
t.cgoEnabled, _ = strconv.ParseBool(parts[0])
t.goExe = parts[1]
t.goTmpDir = parts[2]
if flag.NArg() > 0 && t.runRxStr != "" {
fatalf("the -run regular expression flag is mutually exclusive with test name arguments")
}
t.runNames = flag.Args()
// Set GOTRACEBACK to system if the user didn't set a level explicitly.
// Since we're running tests for Go, we want as much detail as possible
// if something goes wrong.
//
// Set it before running any commands just in case something goes wrong.
if ok := isEnvSet("GOTRACEBACK"); !ok {
if err := os.Setenv("GOTRACEBACK", "system"); err != nil {
if t.keepGoing {
log.Printf("Failed to set GOTRACEBACK: %v", err)
} else {
fatalf("Failed to set GOTRACEBACK: %v", err)
}
}
}
if t.rebuild {
t.out("Building packages and commands.")
// Force rebuild the whole toolchain.
goInstall(toolenv(), gorootBinGo, append([]string{"-a"}, toolchain...)...)
}
if !t.listMode {
if builder := os.Getenv("GO_BUILDER_NAME"); builder == "" {
// Ensure that installed commands are up to date, even with -no-rebuild,
// so that tests that run commands end up testing what's actually on disk.
// If everything is up-to-date, this is a no-op.
// We first build the toolchain twice to allow it to converge,
// as when we first bootstrap.
// See cmdbootstrap for a description of the overall process.
//
// On the builders, we skip this step: we assume that 'dist test' is
// already using the result of a clean build, and because of test sharding
// and virtualization we usually start with a clean GOCACHE, so we would
// end up rebuilding large parts of the standard library that aren't
// otherwise relevant to the actual set of packages under test.
goInstall(toolenv(), gorootBinGo, toolchain...)
goInstall(toolenv(), gorootBinGo, toolchain...)
goInstall(toolenv(), gorootBinGo, "cmd")
}
}
t.timeoutScale = 1
if s := os.Getenv("GO_TEST_TIMEOUT_SCALE"); s != "" {
t.timeoutScale, err = strconv.Atoi(s)
if err != nil {
fatalf("failed to parse $GO_TEST_TIMEOUT_SCALE = %q as integer: %v", s, err)
}
}
if t.runRxStr != "" {
if t.runRxStr[0] == '!' {
t.runRxWant = false
t.runRxStr = t.runRxStr[1:]
} else {
t.runRxWant = true
}
t.runRx = regexp.MustCompile(t.runRxStr)
}
t.registerTests()
if t.listMode {
for _, tt := range t.tests {
fmt.Println(tt.name)
}
return
}
for _, name := range t.runNames {
if !t.isRegisteredTestName(name) {
fatalf("unknown test %q", name)
}
}
// On a few builders, make GOROOT unwritable to catch tests writing to it.
if strings.HasPrefix(os.Getenv("GO_BUILDER_NAME"), "linux-") {
if os.Getuid() == 0 {
// Don't bother making GOROOT unwritable:
// we're running as root, so permissions would have no effect.
} else {
xatexit(t.makeGOROOTUnwritable())
}
}
if err := t.maybeLogMetadata(); err != nil {
t.failed = true
if t.keepGoing {
log.Printf("Failed logging metadata: %v", err)
} else {
fatalf("Failed logging metadata: %v", err)
}
}
for _, dt := range t.tests {
if !t.shouldRunTest(dt.name) {
t.partial = true
continue
}
dt := dt // dt used in background after this iteration
if err := dt.fn(&dt); err != nil {
t.runPending(&dt) // in case that hasn't been done yet
t.failed = true
if t.keepGoing {
log.Printf("Failed: %v", err)
} else {
fatalf("Failed: %v", err)
}
}
}
t.runPending(nil)
timelog("end", "dist test")
if t.failed {
fmt.Println("\nFAILED")
xexit(1)
} else if t.partial {
fmt.Println("\nALL TESTS PASSED (some were excluded)")
} else {
fmt.Println("\nALL TESTS PASSED")
}
}
func (t *tester) shouldRunTest(name string) bool {
if t.runRx != nil {
return t.runRx.MatchString(name) == t.runRxWant
}
if len(t.runNames) == 0 {
return true
}
for _, runName := range t.runNames {
if runName == name {
return true
}
}
return false
}
func (t *tester) maybeLogMetadata() error {
if t.compileOnly {
// We need to run a subprocess to log metadata. Don't do that
// on compile-only runs.
return nil
}
t.out("Test execution environment.")
// Helper binary to print system metadata (CPU model, etc). This is a
// separate binary from dist so it need not build with the bootstrap
// toolchain.
//
// TODO(prattmic): If we split dist bootstrap and dist test then this
// could be simplified to directly use internal/sysinfo here.
return t.dirCmd(filepath.Join(goroot, "src/cmd/internal/metadata"), gorootBinGo, []string{"run", "main.go"}).Run()
}
// goTest represents all options to a "go test" command. The final command will
// combine configuration from goTest and tester flags.
type goTest struct {
timeout time.Duration // If non-zero, override timeout
short bool // If true, force -short
tags []string // Build tags
race bool // Force -race
bench bool // Run benchmarks (briefly), not tests.
runTests string // Regexp of tests to run
cpu string // If non-empty, -cpu flag
goroot string // If non-empty, use alternate goroot for go command
gcflags string // If non-empty, build with -gcflags=all=X
ldflags string // If non-empty, build with -ldflags=X
buildmode string // If non-empty, -buildmode flag
dir string // If non-empty, run in GOROOT/src-relative directory dir
env []string // Environment variables to add, as KEY=VAL. KEY= unsets a variable
// We have both pkg and pkgs as a convenience. Both may be set, in which
// case they will be combined. If both are empty, the default is ".".
pkgs []string // Multiple packages to test
pkg string // A single package to test
testFlags []string // Additional flags accepted by this test
}
// bgCommand returns a go test Cmd. The result has Stdout and Stderr set to nil
// and is intended to be added to the work queue.
func (opts *goTest) bgCommand(t *tester) *exec.Cmd {
goCmd, build, run, pkgs, setupCmd := opts.buildArgs(t)
// Combine the flags.
args := append([]string{"test"}, build...)
if t.compileOnly {
// We can't pass -c with multiple packages, so run the tests but
// tell them not to do anything.
args = append(args, "-run=^$")
} else {
args = append(args, run...)
}
args = append(args, pkgs...)
if !t.compileOnly {
args = append(args, opts.testFlags...)
}
cmd := exec.Command(goCmd, args...)
setupCmd(cmd)
return cmd
}
// command returns a go test Cmd intended to be run immediately.
func (opts *goTest) command(t *tester) *exec.Cmd {
cmd := opts.bgCommand(t)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
return cmd
}
func (opts *goTest) run(t *tester) error {
return opts.command(t).Run()
}
// runHostTest runs a test that should be built and run on the host GOOS/GOARCH,
// but run with GOOS/GOARCH set to the target GOOS/GOARCH. This is for tests
// that do nothing but compile and run other binaries. If the host and target
// are different, then the assumption is that the target is running in an
// emulator and does not have a Go toolchain at all, so the test needs to run on
// the host, but its resulting binaries will be run through a go_exec wrapper
// that runs them on the target.
func (opts *goTest) runHostTest(t *tester) error {
goCmd, build, run, pkgs, setupCmd := opts.buildArgs(t)
// Build the host test binary
if len(pkgs) != 1 {
// We can't compile more than one package.
panic("host tests must have a single test package")
}
if len(opts.env) != 0 {
// It's not clear if these are for the host or the target.
panic("host tests must not have environment variables")
}
f, err := os.CreateTemp(t.goTmpDir, "test.test-*"+t.goExe)
if err != nil {
fatalf("failed to create temporary file: %s", err)
}
bin := f.Name()
f.Close()
xatexit(func() { os.Remove(bin) })
args := append([]string{"test", "-c", "-o", bin}, build...)
args = append(args, pkgs...)
cmd := exec.Command(goCmd, args...)
setupCmd(cmd)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
setEnv(cmd, "GOARCH", gohostarch)
setEnv(cmd, "GOOS", gohostos)
if vflag > 1 {
errprintf("%s\n", cmd)
}
if err := cmd.Run(); err != nil {
return err
}
if t.compileOnly {
return nil
}
// Transform run flags to be passed directly to a test binary.
for i, f := range run {
if !strings.HasPrefix(f, "-") {
panic("run flag does not start with -: " + f)
}
run[i] = "-test." + f[1:]
}
// Run the test
args = append(run, opts.testFlags...)
cmd = exec.Command(bin, args...)
setupCmd(cmd)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if vflag > 1 {
errprintf("%s\n", cmd)
}
return cmd.Run()
}
// buildArgs is in internal helper for goTest that constructs the elements of
// the "go test" command line. goCmd is the path to the go command to use. build
// is the flags for building the test. run is the flags for running the test.
// pkgs is the list of packages to build and run.
//
// The caller is responsible for adding opts.testFlags, and must call setupCmd
// on the resulting exec.Cmd to set its directory and environment.
func (opts *goTest) buildArgs(t *tester) (goCmd string, build, run, pkgs []string, setupCmd func(*exec.Cmd)) {
goCmd = gorootBinGo
if opts.goroot != "" {
goCmd = filepath.Join(opts.goroot, "bin", "go")
}
run = append(run, "-count=1") // Disallow caching
if opts.timeout != 0 {
d := opts.timeout * time.Duration(t.timeoutScale)
run = append(run, "-timeout="+d.String())
}
if opts.short || t.short {
run = append(run, "-short")
}
var tags []string
if t.iOS() {
tags = append(tags, "lldb")
}
if noOpt {
tags = append(tags, "noopt")
}
tags = append(tags, opts.tags...)
if len(tags) > 0 {
build = append(build, "-tags="+strings.Join(tags, ","))
}
if t.race || opts.race {
build = append(build, "-race")
}
if t.msan {
build = append(build, "-msan")
}
if t.asan {
build = append(build, "-asan")
}
if opts.bench {
// Run no tests.
run = append(run, "-run=^$")
// Run benchmarks as a smoke test
run = append(run, "-bench=.*", "-benchtime=.1s")
} else if opts.runTests != "" {
run = append(run, "-run="+opts.runTests)
}
if opts.cpu != "" {
run = append(run, "-cpu="+opts.cpu)
}
if opts.gcflags != "" {
build = append(build, "-gcflags=all="+opts.gcflags)
}
if opts.ldflags != "" {
build = append(build, "-ldflags="+opts.ldflags)
}
if opts.buildmode != "" {
build = append(build, "-buildmode="+opts.buildmode)
}
pkgs = opts.pkgs
if opts.pkg != "" {
pkgs = append(pkgs[:len(pkgs):len(pkgs)], opts.pkg)
}
if len(pkgs) == 0 {
pkgs = []string{"."}
}
thisGoroot := goroot
if opts.goroot != "" {
thisGoroot = opts.goroot
}
var dir string
if opts.dir != "" {
if filepath.IsAbs(opts.dir) {
panic("dir must be relative, got: " + opts.dir)
}
dir = filepath.Join(thisGoroot, "src", opts.dir)
} else {
dir = filepath.Join(thisGoroot, "src")
}
setupCmd = func(cmd *exec.Cmd) {
setDir(cmd, dir)
if len(opts.env) != 0 {
for _, kv := range opts.env {
if i := strings.Index(kv, "="); i < 0 {
unsetEnv(cmd, kv[:len(kv)-1])
} else {
setEnv(cmd, kv[:i], kv[i+1:])
}
}
}
}
return
}
// ranGoTest and stdMatches are state closed over by the stdlib
// testing func in registerStdTest below. The tests are run
// sequentially, so there's no need for locks.
//
// ranGoBench and benchMatches are the same, but are only used
// in -race mode.
var (
ranGoTest bool
stdMatches []string
ranGoBench bool
benchMatches []string
)
func (t *tester) registerStdTest(pkg string) {
heading := "Testing packages."
testPrefix := "go_test:"
gcflags := gogcflags
testName := testPrefix + pkg
if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant {
stdMatches = append(stdMatches, pkg)
}
t.tests = append(t.tests, distTest{
name: testName,
heading: heading,
fn: func(dt *distTest) error {
if ranGoTest {
return nil
}
t.runPending(dt)
timelog("start", dt.name)
defer timelog("end", dt.name)
ranGoTest = true
timeoutSec := 180 * time.Second
for _, pkg := range stdMatches {
if pkg == "cmd/go" {
timeoutSec *= 3
break
}
}
return (&goTest{
timeout: timeoutSec,
gcflags: gcflags,
pkgs: stdMatches,
}).run(t)
},
})
}
func (t *tester) registerRaceBenchTest(pkg string) {
testName := "go_test_bench:" + pkg
if t.runRx == nil || t.runRx.MatchString(testName) == t.runRxWant {
benchMatches = append(benchMatches, pkg)
}
t.tests = append(t.tests, distTest{
name: testName,
heading: "Running benchmarks briefly.",
fn: func(dt *distTest) error {
if ranGoBench {
return nil
}
t.runPending(dt)
timelog("start", dt.name)
defer timelog("end", dt.name)
ranGoBench = true
return (&goTest{
timeout: 1200 * time.Second, // longer timeout for race with benchmarks
race: true,
bench: true,
cpu: "4",
pkgs: benchMatches,
}).run(t)
},
})
}
func (t *tester) registerTests() {
// registerStdTestSpecially tracks import paths in the standard library
// whose test registration happens in a special way.
registerStdTestSpecially := map[string]bool{
"internal/testdir": true, // Registered at the bottom with sharding.
}
// Fast path to avoid the ~1 second of `go list std cmd` when
// the caller lists specific tests to run. (as the continuous
// build coordinator does).
if len(t.runNames) > 0 {
for _, name := range t.runNames {
if strings.HasPrefix(name, "go_test:") {
t.registerStdTest(strings.TrimPrefix(name, "go_test:"))
}
if strings.HasPrefix(name, "go_test_bench:") {
t.registerRaceBenchTest(strings.TrimPrefix(name, "go_test_bench:"))
}
}
} else {
// Use a format string to only list packages and commands that have tests.
const format = "{{if (or .TestGoFiles .XTestGoFiles)}}{{.ImportPath}}{{end}}"
cmd := exec.Command(gorootBinGo, "list", "-f", format)
if t.race {
cmd.Args = append(cmd.Args, "-tags=race")
}
cmd.Args = append(cmd.Args, "std", "cmd")
cmd.Stderr = new(bytes.Buffer)
all, err := cmd.Output()
if err != nil {
fatalf("Error running go list std cmd: %v:\n%s", err, cmd.Stderr)
}
pkgs := strings.Fields(string(all))
for _, pkg := range pkgs {
if registerStdTestSpecially[pkg] {
continue
}
t.registerStdTest(pkg)
}
if t.race {
for _, pkg := range pkgs {
if registerStdTestSpecially[pkg] {
continue
}
if t.packageHasBenchmarks(pkg) {
t.registerRaceBenchTest(pkg)
}
}
}
}
if t.race {
return
}
// Test the os/user package in the pure-Go mode too.
if !t.compileOnly {
t.registerTest("osusergo", "os/user with tag osusergo",
&goTest{
timeout: 300 * time.Second,
tags: []string{"osusergo"},
pkg: "os/user",
})
t.registerTest("purego:hash/maphash", "hash/maphash purego implementation",
&goTest{
timeout: 300 * time.Second,
tags: []string{"purego"},
pkg: "hash/maphash",
})
}
// Test ios/amd64 for the iOS simulator.
if goos == "darwin" && goarch == "amd64" && t.cgoEnabled {
t.registerTest("amd64ios", "GOOS=ios on darwin/amd64",
&goTest{
timeout: 300 * time.Second,
runTests: "SystemRoots",
env: []string{"GOOS=ios", "CGO_ENABLED=1"},
pkg: "crypto/x509",
})
}
// Runtime CPU tests.
if !t.compileOnly && goos != "js" { // js can't handle -cpu != 1
t.registerTest("runtime:cpu124", "GOMAXPROCS=2 runtime -cpu=1,2,4 -quick",
&goTest{
timeout: 300 * time.Second,
cpu: "1,2,4",
short: true,
testFlags: []string{"-quick"},
// We set GOMAXPROCS=2 in addition to -cpu=1,2,4 in order to test runtime bootstrap code,
// creation of first goroutines and first garbage collections in the parallel setting.
env: []string{"GOMAXPROCS=2"},
pkg: "runtime",
})
}
// morestack tests. We only run these on in long-test mode
// (with GO_TEST_SHORT=false) because the runtime test is
// already quite long and mayMoreStackMove makes it about
// twice as slow.
if !t.compileOnly && !t.short {
// hooks is the set of maymorestack hooks to test with.
hooks := []string{"mayMoreStackPreempt", "mayMoreStackMove"}
// pkgs is the set of test packages to run.
pkgs := []string{"runtime", "reflect", "sync"}
// hookPkgs is the set of package patterns to apply
// the maymorestack hook to.
hookPkgs := []string{"runtime/...", "reflect", "sync"}
// unhookPkgs is the set of package patterns to
// exclude from hookPkgs.
unhookPkgs := []string{"runtime/testdata/..."}
for _, hook := range hooks {
// Construct the build flags to use the
// maymorestack hook in the compiler and
// assembler. We pass this via the GOFLAGS
// environment variable so that it applies to
// both the test itself and to binaries built
// by the test.
goFlagsList := []string{}
for _, flag := range []string{"-gcflags", "-asmflags"} {
for _, hookPkg := range hookPkgs {
goFlagsList = append(goFlagsList, flag+"="+hookPkg+"=-d=maymorestack=runtime."+hook)
}
for _, unhookPkg := range unhookPkgs {
goFlagsList = append(goFlagsList, flag+"="+unhookPkg+"=")
}
}
goFlags := strings.Join(goFlagsList, " ")
for _, pkg := range pkgs {
t.registerTest(hook+":"+pkg, "maymorestack="+hook,
&goTest{
timeout: 600 * time.Second,
short: true,
env: []string{"GOFLAGS=" + goFlags},
pkg: pkg,
})
}
}
}
// On the builders only, test that a moved GOROOT still works.
// Fails on iOS because CC_FOR_TARGET refers to clangwrap.sh
// in the unmoved GOROOT.
// Fails on Android and js/wasm with an exec format error.
// Fails on plan9 with "cannot find GOROOT" (issue #21016).
if os.Getenv("GO_BUILDER_NAME") != "" && goos != "android" && !t.iOS() && goos != "plan9" && goos != "js" {
t.tests = append(t.tests, distTest{
name: "moved_goroot",
heading: "moved GOROOT",
fn: func(dt *distTest) error {
t.runPending(dt)
timelog("start", dt.name)
defer timelog("end", dt.name)
moved := goroot + "-moved"
if err := os.Rename(goroot, moved); err != nil {
if goos == "windows" {
// Fails on Windows (with "Access is denied") if a process
// or binary is in this directory. For instance, using all.bat
// when run from c:\workdir\go\src fails here
// if GO_BUILDER_NAME is set. Our builders invoke tests
// a different way which happens to work when sharding
// tests, but we should be tolerant of the non-sharded
// all.bat case.
log.Printf("skipping test on Windows")
return nil
}
return err
}
// Run `go test fmt` in the moved GOROOT, without explicitly setting
// GOROOT in the environment. The 'go' command should find itself.
cmd := (&goTest{
goroot: moved,
pkg: "fmt",
}).command(t)
unsetEnv(cmd, "GOROOT")
err := cmd.Run()
if rerr := os.Rename(moved, goroot); rerr != nil {
fatalf("failed to restore GOROOT: %v", rerr)
}
return err
},
})
}
// Test that internal linking of standard packages does not
// require libgcc. This ensures that we can install a Go
// release on a system that does not have a C compiler
// installed and still build Go programs (that don't use cgo).
for _, pkg := range cgoPackages {
if !t.internalLink() {
break
}
// ARM libgcc may be Thumb, which internal linking does not support.
if goarch == "arm" {
break
}
// What matters is that the tests build and start up.
// Skip expensive tests, especially x509 TestSystemRoots.
run := "^Test[^CS]"
if pkg == "net" {
run = "TestTCPStress"
}
t.registerTest("nolibgcc:"+pkg, "Testing without libgcc.",
&goTest{
ldflags: "-linkmode=internal -libgcc=none",
runTests: run,
pkg: pkg,
})
}
// Stub out following test on alpine until 54354 resolved.
builderName := os.Getenv("GO_BUILDER_NAME")
disablePIE := strings.HasSuffix(builderName, "-alpine")
// Test internal linking of PIE binaries where it is supported.
if t.internalLinkPIE() && !disablePIE {
t.registerTest("pie_internal", "internal linking of -buildmode=pie",
&goTest{
timeout: 60 * time.Second,
buildmode: "pie",
ldflags: "-linkmode=internal",
env: []string{"CGO_ENABLED=0"},
pkg: "reflect",
})
// Also test a cgo package.
if t.cgoEnabled && t.internalLink() && !disablePIE {
t.registerTest("pie_internal_cgo", "internal linking of -buildmode=pie",
&goTest{
timeout: 60 * time.Second,
buildmode: "pie",
ldflags: "-linkmode=internal",
pkg: "os/user",
})
}
}
// sync tests
if goos != "js" { // js doesn't support -cpu=10
t.registerTest("sync_cpu", "sync -cpu=10",
&goTest{
timeout: 120 * time.Second,
cpu: "10",
pkg: "sync",
})
}
if t.raceDetectorSupported() {
t.registerRaceTests()
}
if t.cgoEnabled && !t.iOS() {
// Disabled on iOS. golang.org/issue/15919
t.registerTest("cgo_stdio", "", &goTest{dir: "../misc/cgo/stdio", timeout: 5 * time.Minute}, rtHostTest{})
t.registerTest("cgo_life", "", &goTest{dir: "../misc/cgo/life", timeout: 5 * time.Minute}, rtHostTest{})
if goos != "android" {
t.registerTest("cgo_fortran", "", &goTest{dir: "../misc/cgo/fortran", timeout: 5 * time.Minute}, rtHostTest{})
}
if t.hasSwig() && goos != "android" {
t.registerTest("swig_stdio", "", &goTest{dir: "../misc/swig/stdio"})
if t.hasCxx() {
t.registerTest("swig_callback", "", &goTest{dir: "../misc/swig/callback"})
const cflags = "-flto -Wno-lto-type-mismatch -Wno-unknown-warning-option"
t.registerTest("swig_callback_lto", "",
&goTest{
dir: "../misc/swig/callback",
env: []string{
"CGO_CFLAGS=" + cflags,
"CGO_CXXFLAGS=" + cflags,
"CGO_LDFLAGS=" + cflags,
},
})
}
}
}
if t.cgoEnabled {
t.registerCgoTests()
}
// Don't run these tests with $GO_GCFLAGS because most of them
// assume that they can run "go install" with no -gcflags and not
// recompile the entire standard library. If make.bash ran with
// special -gcflags, that's not true.
if t.cgoEnabled && gogcflags == "" {
t.registerTest("testgodefs", "", &goTest{dir: "../misc/cgo/testgodefs", timeout: 5 * time.Minute}, rtHostTest{})
t.registerTest("testso", "", &goTest{dir: "../misc/cgo/testso", timeout: 600 * time.Second})
t.registerTest("testsovar", "", &goTest{dir: "../misc/cgo/testsovar", timeout: 600 * time.Second})
if t.supportedBuildmode("c-archive") {
t.registerTest("testcarchive", "", &goTest{dir: "../misc/cgo/testcarchive", timeout: 5 * time.Minute}, rtHostTest{})
}
if t.supportedBuildmode("c-shared") {
t.registerTest("testcshared", "", &goTest{dir: "../misc/cgo/testcshared", timeout: 5 * time.Minute}, rtHostTest{})
}
if t.supportedBuildmode("shared") {
t.registerTest("testshared", "", &goTest{dir: "../misc/cgo/testshared", timeout: 600 * time.Second})
}
if t.supportedBuildmode("plugin") {
t.registerTest("testplugin", "", &goTest{dir: "../misc/cgo/testplugin", timeout: 600 * time.Second})
}
if goos == "linux" || (goos == "freebsd" && goarch == "amd64") {
// because Pdeathsig of syscall.SysProcAttr struct used in misc/cgo/testsanitizers is only
// supported on Linux and FreeBSD.
t.registerTest("testsanitizers", "", &goTest{dir: "../misc/cgo/testsanitizers", timeout: 5 * time.Minute}, rtHostTest{})
}
if t.hasBash() && goos != "android" && !t.iOS() && gohostos != "windows" {
t.registerTest("cgo_errors", "", &goTest{dir: "../misc/cgo/errors", timeout: 5 * time.Minute}, rtHostTest{})
}
}
if goos != "android" && !t.iOS() {
// There are no tests in this directory, only benchmarks.
// Check that the test binary builds.
t.registerTest("bench_go1", "", &goTest{dir: "../test/bench/go1"})
}
if goos != "android" && !t.iOS() {
// Only start multiple test dir shards on builders,
// where they get distributed to multiple machines.
// See issues 20141 and 31834.
nShards := 1
if os.Getenv("GO_BUILDER_NAME") != "" {
nShards = 10
}
if n, err := strconv.Atoi(os.Getenv("GO_TEST_SHARDS")); err == nil {
nShards = n
}
for shard := 0; shard < nShards; shard++ {
t.registerTest(
fmt.Sprintf("test:%d_%d", shard, nShards),
"../test",
&goTest{
dir: "internal/testdir",
testFlags: []string{fmt.Sprintf("-shard=%d", shard), fmt.Sprintf("-shards=%d", nShards)},
},
rtHostTest{},
)
}
}
// Only run the API check on fast development platforms.
// Every platform checks the API on every GOOS/GOARCH/CGO_ENABLED combination anyway,
// so we really only need to run this check once anywhere to get adequate coverage.
// To help developers avoid trybot-only failures, we try to run on typical developer machines
// which is darwin,linux,windows/amd64 and darwin/arm64.
if goos == "darwin" || ((goos == "linux" || goos == "windows") && goarch == "amd64") {
t.registerTest("api", "", &goTest{dir: "cmd/api", timeout: 5 * time.Minute, testFlags: []string{"-check"}})
}
// Ensure that the toolchain can bootstrap itself.
// This test adds another ~45s to all.bash if run sequentially, so run it only on the builders.
if os.Getenv("GO_BUILDER_NAME") != "" && goos != "android" && !t.iOS() {
t.registerTest("reboot", "", &goTest{dir: "../misc/reboot", timeout: 5 * time.Minute}, rtHostTest{})
}
}
// isRegisteredTestName reports whether a test named testName has already
// been registered.
func (t *tester) isRegisteredTestName(testName string) bool {
for _, tt := range t.tests {
if tt.name == testName {
return true
}
}
return false
}
type registerTestOpt interface {
isRegisterTestOpt()
}
// rtSequential is a registerTest option that causes the registered test to run
// sequentially.
type rtSequential struct{}
func (rtSequential) isRegisterTestOpt() {}
// rtPreFunc is a registerTest option that runs a pre function before running
// the test.
type rtPreFunc struct {
pre func(*distTest) bool // Return false to skip the test
}
func (rtPreFunc) isRegisterTestOpt() {}
// rtHostTest is a registerTest option that indicates this is a host test that
// should be run using goTest.runHostTest. It implies rtSequential.
type rtHostTest struct{}
func (rtHostTest) isRegisterTestOpt() {}
// registerTest registers a test that runs the given goTest.
//
// If heading is "", it uses test.dir as the heading.
func (t *tester) registerTest(name, heading string, test *goTest, opts ...registerTestOpt) {
seq := false
hostTest := false
var preFunc func(*distTest) bool
for _, opt := range opts {
switch opt := opt.(type) {
case rtSequential:
seq = true
case rtPreFunc:
preFunc = opt.pre
case rtHostTest:
seq, hostTest = true, true
}
}
if t.isRegisteredTestName(name) {
panic("duplicate registered test name " + name)
}
if heading == "" {
heading = test.dir
}
t.tests = append(t.tests, distTest{
name: name,
heading: heading,
fn: func(dt *distTest) error {
if preFunc != nil && !preFunc(dt) {
return nil
}
if seq {
t.runPending(dt)
if hostTest {
return test.runHostTest(t)
}
return test.run(t)
}
w := &work{
dt: dt,
cmd: test.bgCommand(t),
}
t.worklist = append(t.worklist, w)
return nil
},
})
}
// bgDirCmd constructs a Cmd intended to be run in the background as
// part of the worklist. The worklist runner will buffer its output
// and replay it sequentially. The command will be run in dir.
func (t *tester) bgDirCmd(dir, bin string, args ...string) *exec.Cmd {
cmd := exec.Command(bin, args...)
if filepath.IsAbs(dir) {
setDir(cmd, dir)
} else {
setDir(cmd, filepath.Join(goroot, dir))
}
return cmd
}
// dirCmd constructs a Cmd intended to be run in the foreground.
// The command will be run in dir, and Stdout and Stderr will go to os.Stdout
// and os.Stderr.
func (t *tester) dirCmd(dir string, cmdline ...interface{}) *exec.Cmd {
bin, args := flattenCmdline(cmdline)
cmd := t.bgDirCmd(dir, bin, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
if vflag > 1 {
errprintf("%s\n", strings.Join(cmd.Args, " "))
}
return cmd
}
// flattenCmdline flattens a mixture of string and []string as single list
// and then interprets it as a command line: first element is binary, then args.
func flattenCmdline(cmdline []interface{}) (bin string, args []string) {
var list []string
for _, x := range cmdline {
switch x := x.(type) {
case string:
list = append(list, x)
case []string:
list = append(list, x...)
default:
panic("invalid addCmd argument type: " + reflect.TypeOf(x).String())
}
}
bin = list[0]
if !filepath.IsAbs(bin) {
panic("command is not absolute: " + bin)
}
return bin, list[1:]
}
// addCmd adds a command to the worklist. Commands can be run in
// parallel, but their output will be buffered and replayed in the
// order they were added to worklist.
func (t *tester) addCmd(dt *distTest, dir string, cmdline ...interface{}) *exec.Cmd {
bin, args := flattenCmdline(cmdline)
w := &work{
dt: dt,
cmd: t.bgDirCmd(dir, bin, args...),
}
t.worklist = append(t.worklist, w)
return w.cmd
}
func (t *tester) iOS() bool {
return goos == "ios"
}
func (t *tester) out(v string) {
if t.banner == "" {
return
}
fmt.Println("\n" + t.banner + v)
}
// extLink reports whether the current goos/goarch supports
// external linking. This should match the test in determineLinkMode
// in cmd/link/internal/ld/config.go.
func (t *tester) extLink() bool {
if goarch == "ppc64" && goos != "aix" {
return false
}
return true
}
func (t *tester) internalLink() bool {
if gohostos == "dragonfly" {
// linkmode=internal fails on dragonfly since errno is a TLS relocation.
return false
}
if goos == "android" {
return false
}
if goos == "ios" {
return false
}
if goos == "windows" && goarch == "arm64" {
return false
}
// Internally linking cgo is incomplete on some architectures.
// https://golang.org/issue/10373
// https://golang.org/issue/14449
if goarch == "loong64" || goarch == "mips64" || goarch == "mips64le" || goarch == "mips" || goarch == "mipsle" || goarch == "riscv64" {
return false
}
if goos == "aix" {
// linkmode=internal isn't supported.
return false
}
return true
}
func (t *tester) internalLinkPIE() bool {
switch goos + "-" + goarch {
case "darwin-amd64", "darwin-arm64",
"linux-amd64", "linux-arm64", "linux-ppc64le",
"android-arm64",
"windows-amd64", "windows-386", "windows-arm":
return true
}
return false
}
// supportedBuildMode reports whether the given build mode is supported.
func (t *tester) supportedBuildmode(mode string) bool {
switch mode {
case "c-archive", "c-shared", "shared", "plugin", "pie":
default:
fatalf("internal error: unknown buildmode %s", mode)
return false
}
return buildModeSupported("gc", mode, goos, goarch)
}
func (t *tester) registerCgoTests() {
cgoTest := func(name string, subdir, linkmode, buildmode string, opts ...registerTestOpt) *goTest {
gt := &goTest{
dir: "../misc/cgo/" + subdir,
buildmode: buildmode,
ldflags: "-linkmode=" + linkmode,
}
if linkmode == "internal" {
gt.tags = append(gt.tags, "internal")
if buildmode == "pie" {
gt.tags = append(gt.tags, "internal_pie")
}
}
if buildmode == "static" {
// This isn't actually a Go buildmode, just a convenient way to tell
// cgoTest we want static linking.
gt.buildmode = ""
if linkmode == "external" {
gt.ldflags += ` -extldflags "-static -pthread"`
} else if linkmode == "auto" {
gt.env = append(gt.env, "CGO_LDFLAGS=-static -pthread")
} else {
panic("unknown linkmode with static build: " + linkmode)
}
gt.tags = append(gt.tags, "static")
}
t.registerTest("cgo:"+name, "../misc/cgo/test", gt, opts...)
return gt
}
cgoTest("test-auto", "test", "auto", "")
// Stub out various buildmode=pie tests on alpine until 54354 resolved.
builderName := os.Getenv("GO_BUILDER_NAME")
disablePIE := strings.HasSuffix(builderName, "-alpine")
if t.internalLink() {
cgoTest("test-internal", "test", "internal", "")
}
os := gohostos
p := gohostos + "/" + goarch
switch {
case os == "darwin", os == "windows":
if !t.extLink() {
break
}
// test linkmode=external, but __thread not supported, so skip testtls.
cgoTest("test-external", "test", "external", "")
gt := cgoTest("test-external-s", "test", "external", "")
gt.ldflags += " -s"
if t.supportedBuildmode("pie") && !disablePIE {
cgoTest("test-auto-pie", "test", "auto", "pie")
if t.internalLink() && t.internalLinkPIE() {
cgoTest("test-internal-pie", "test", "internal", "pie")
}
}
case os == "aix", os == "android", os == "dragonfly", os == "freebsd", os == "linux", os == "netbsd", os == "openbsd":
gt := cgoTest("test-external-g0", "test", "external", "")
gt.env = append(gt.env, "CGO_CFLAGS=-g0 -fdiagnostics-color")
cgoTest("testtls-auto", "testtls", "auto", "")
cgoTest("testtls-external", "testtls", "external", "")
switch {
case os == "aix":
// no static linking
case p == "freebsd/arm":
// -fPIC compiled tls code will use __tls_get_addr instead
// of __aeabi_read_tp, however, on FreeBSD/ARM, __tls_get_addr
// is implemented in rtld-elf, so -fPIC isn't compatible with
// static linking on FreeBSD/ARM with clang. (cgo depends on
// -fPIC fundamentally.)
default:
// Check for static linking support
var staticCheck rtPreFunc
ccName := compilerEnvLookup("CC", defaultcc, goos, goarch)
cc, err := exec.LookPath(ccName)
if err != nil {
staticCheck.pre = func(*distTest) bool {
fmt.Printf("$CC (%q) not found, skip cgo static linking test.\n", ccName)
return false
}
} else {
cmd := t.dirCmd("misc/cgo/test", cc, "-xc", "-o", "/dev/null", "-static", "-")
cmd.Stdin = strings.NewReader("int main() {}")
cmd.Stdout, cmd.Stderr = nil, nil // Discard output
if err := cmd.Run(); err != nil {
// Skip these tests
staticCheck.pre = func(*distTest) bool {
fmt.Println("No support for static linking found (lacks libc.a?), skip cgo static linking test.")
return false
}
}
}
// Static linking tests
if goos != "android" && p != "netbsd/arm" {
// TODO(#56629): Why does this fail on netbsd-arm?
cgoTest("testtls-static", "testtls", "external", "static", staticCheck)
}
cgoTest("nocgo-auto", "nocgo", "auto", "", staticCheck)
cgoTest("nocgo-external", "nocgo", "external", "", staticCheck)
if goos != "android" {
cgoTest("nocgo-static", "nocgo", "external", "static", staticCheck)
cgoTest("test-static", "test", "external", "static", staticCheck)
// -static in CGO_LDFLAGS triggers a different code path
// than -static in -extldflags, so test both.
// See issue #16651.
if goarch != "loong64" {
// TODO(#56623): Why does this fail on loong64?
cgoTest("test-static-env", "test", "auto", "static", staticCheck)
}
}
// PIE linking tests
if t.supportedBuildmode("pie") && !disablePIE {
cgoTest("test-pie", "test", "auto", "pie")
if t.internalLink() && t.internalLinkPIE() {
cgoTest("test-pie-internal", "test", "internal", "pie")
}
cgoTest("testtls-pie", "testtls", "auto", "pie")
cgoTest("nocgo-pie", "nocgo", "auto", "pie")
}
}
}
}
// run pending test commands, in parallel, emitting headers as appropriate.
// When finished, emit header for nextTest, which is going to run after the
// pending commands are done (and runPending returns).
// A test should call runPending if it wants to make sure that it is not
// running in parallel with earlier tests, or if it has some other reason
// for needing the earlier tests to be done.
func (t *tester) runPending(nextTest *distTest) {
worklist := t.worklist
t.worklist = nil
for _, w := range worklist {
w.start = make(chan bool)
w.end = make(chan bool)
go func(w *work) {
if !<-w.start {
timelog("skip", w.dt.name)
w.out = []byte(fmt.Sprintf("skipped due to earlier error\n"))
} else {
timelog("start", w.dt.name)
w.out, w.err = w.cmd.CombinedOutput()
if w.err != nil {
if isUnsupportedVMASize(w) {
timelog("skip", w.dt.name)
w.out = []byte(fmt.Sprintf("skipped due to unsupported VMA\n"))
w.err = nil
}
}
}
timelog("end", w.dt.name)
w.end <- true
}(w)
}
started := 0
ended := 0
var last *distTest
for ended < len(worklist) {
for started < len(worklist) && started-ended < maxbg {
w := worklist[started]
started++
w.start <- !t.failed || t.keepGoing
}
w := worklist[ended]
dt := w.dt
if dt.heading != "" && t.lastHeading != dt.heading {
t.lastHeading = dt.heading
t.out(dt.heading)
}
if dt != last {
// Assumes all the entries for a single dt are in one worklist.
last = w.dt
if vflag > 0 {
fmt.Printf("# go tool dist test -run=^%s$\n", dt.name)
}
}
if vflag > 1 {
errprintf("%s\n", strings.Join(w.cmd.Args, " "))
}
ended++
<-w.end
os.Stdout.Write(w.out)
if w.err != nil {
log.Printf("Failed: %v", w.err)
t.failed = true
}
}
if t.failed && !t.keepGoing {
fatalf("FAILED")
}
if dt := nextTest; dt != nil {
if dt.heading != "" && t.lastHeading != dt.heading {
t.lastHeading = dt.heading
t.out(dt.heading)
}
if vflag > 0 {
fmt.Printf("# go tool dist test -run=^%s$\n", dt.name)
}
}
}
func (t *tester) hasBash() bool {
switch gohostos {
case "windows", "plan9":
return false
}
return true
}
func (t *tester) hasCxx() bool {
cxx, _ := exec.LookPath(compilerEnvLookup("CXX", defaultcxx, goos, goarch))
return cxx != ""
}
func (t *tester) hasSwig() bool {
swig, err := exec.LookPath("swig")
if err != nil {
return false
}
// Check that swig was installed with Go support by checking
// that a go directory exists inside the swiglib directory.
// See https://golang.org/issue/23469.
output, err := exec.Command(swig, "-go", "-swiglib").Output()
if err != nil {
return false
}
swigDir := strings.TrimSpace(string(output))
_, err = os.Stat(filepath.Join(swigDir, "go"))
if err != nil {
return false
}
// Check that swig has a new enough version.
// See https://golang.org/issue/22858.
out, err := exec.Command(swig, "-version").CombinedOutput()
if err != nil {
return false
}
re := regexp.MustCompile(`[vV]ersion +(\d+)([.]\d+)?([.]\d+)?`)
matches := re.FindSubmatch(out)
if matches == nil {
// Can't find version number; hope for the best.
return true
}
major, err := strconv.Atoi(string(matches[1]))
if err != nil {
// Can't find version number; hope for the best.
return true
}
if major < 3 {
return false
}
if major > 3 {
// 4.0 or later
return true
}
// We have SWIG version 3.x.
if len(matches[2]) > 0 {
minor, err := strconv.Atoi(string(matches[2][1:]))
if err != nil {
return true
}
if minor > 0 {
// 3.1 or later
return true
}
}
// We have SWIG version 3.0.x.
if len(matches[3]) > 0 {
patch, err := strconv.Atoi(string(matches[3][1:]))
if err != nil {
return true
}
if patch < 6 {
// Before 3.0.6.
return false
}
}
return true
}
func (t *tester) raceDetectorSupported() bool {
if gohostos != goos {
return false
}
if !t.cgoEnabled {
return false
}
if !raceDetectorSupported(goos, goarch) {
return false
}
// The race detector doesn't work on Alpine Linux:
// golang.org/issue/14481
if isAlpineLinux() {
return false
}
// NetBSD support is unfinished.
// golang.org/issue/26403
if goos == "netbsd" {
return false
}
return true
}
func isAlpineLinux() bool {
if runtime.GOOS != "linux" {
return false
}
fi, err := os.Lstat("/etc/alpine-release")
return err == nil && fi.Mode().IsRegular()
}
func (t *tester) registerRaceTests() {
hdr := "Testing race detector"
t.registerTest("race:runtime/race", hdr,
&goTest{
race: true,
runTests: "Output",
pkg: "runtime/race",
})
t.registerTest("race", hdr,
&goTest{
race: true,
runTests: "TestParse|TestEcho|TestStdinCloseRace|TestClosedPipeRace|TestTypeRace|TestFdRace|TestFdReadRace|TestFileCloseRace",
pkgs: []string{"flag", "net", "os", "os/exec", "encoding/gob"},
})
// We don't want the following line, because it
// slows down all.bash (by 10 seconds on my laptop).
// The race builder should catch any error here, but doesn't.
// TODO(iant): Figure out how to catch this.
// t.registerTest("race:cmd/go", hdr, &goTest{race: true, runTests: "TestParallelTest", pkg: "cmd/go"})
if t.cgoEnabled {
// Building misc/cgo/test takes a long time.
// There are already cgo-enabled packages being tested with the race detector.
// We shouldn't need to redo all of misc/cgo/test too.
// The race buildler will take care of this.
// t.registerTest("race:misc/cgo/test", hdr, &goTest{dir: "../misc/cgo/test", race: true, env: []string{"GOTRACEBACK=2"}})
}
if t.extLink() {
// Test with external linking; see issue 9133.
t.registerTest("race:external", hdr,
&goTest{
race: true,
ldflags: "-linkmode=external",
runTests: "TestParse|TestEcho|TestStdinCloseRace",
pkgs: []string{"flag", "os/exec"},
})
}
}
// cgoPackages is the standard packages that use cgo.
var cgoPackages = []string{
"net",
"os/user",
}
var funcBenchmark = []byte("\nfunc Benchmark")
// packageHasBenchmarks reports whether pkg has benchmarks.
// On any error, it conservatively returns true.
//
// This exists just to eliminate work on the builders, since compiling
// a test in race mode just to discover it has no benchmarks costs a
// second or two per package, and this function returns false for
// about 100 packages.
func (t *tester) packageHasBenchmarks(pkg string) bool {
pkgDir := filepath.Join(goroot, "src", pkg)
d, err := os.Open(pkgDir)
if err != nil {
return true // conservatively
}
defer d.Close()
names, err := d.Readdirnames(-1)
if err != nil {
return true // conservatively
}
for _, name := range names {
if !strings.HasSuffix(name, "_test.go") {
continue
}
slurp, err := os.ReadFile(filepath.Join(pkgDir, name))
if err != nil {
return true // conservatively
}
if bytes.Contains(slurp, funcBenchmark) {
return true
}
}
return false
}
// makeGOROOTUnwritable makes all $GOROOT files & directories non-writable to
// check that no tests accidentally write to $GOROOT.
func (t *tester) makeGOROOTUnwritable() (undo func()) {
dir := os.Getenv("GOROOT")
if dir == "" {
panic("GOROOT not set")
}
type pathMode struct {
path string
mode os.FileMode
}
var dirs []pathMode // in lexical order
undo = func() {
for i := range dirs {
os.Chmod(dirs[i].path, dirs[i].mode) // best effort
}
}
filepath.WalkDir(dir, func(path string, d fs.DirEntry, err error) error {
if suffix := strings.TrimPrefix(path, dir+string(filepath.Separator)); suffix != "" {
if suffix == ".git" {
// Leave Git metadata in whatever state it was in. It may contain a lot
// of files, and it is highly unlikely that a test will try to modify
// anything within that directory.
return filepath.SkipDir
}
}
if err != nil {
return nil
}
info, err := d.Info()
if err != nil {
return nil
}
mode := info.Mode()
if mode&0222 != 0 && (mode.IsDir() || mode.IsRegular()) {
dirs = append(dirs, pathMode{path, mode})
}
return nil
})
// Run over list backward to chmod children before parents.
for i := len(dirs) - 1; i >= 0; i-- {
err := os.Chmod(dirs[i].path, dirs[i].mode&^0222)
if err != nil {
dirs = dirs[i:] // Only undo what we did so far.
undo()
fatalf("failed to make GOROOT read-only: %v", err)
}
}
return undo
}
// raceDetectorSupported is a copy of the function
// internal/platform.RaceDetectorSupported, which can't be used here
// because cmd/dist can not import internal packages during bootstrap.
// The race detector only supports 48-bit VMA on arm64. But we don't have
// a good solution to check VMA size(See https://golang.org/issue/29948)
// raceDetectorSupported will always return true for arm64. But race
// detector tests may abort on non 48-bit VMA configuration, the tests
// will be marked as "skipped" in this case.
func raceDetectorSupported(goos, goarch string) bool {
switch goos {
case "linux":
return goarch == "amd64" || goarch == "ppc64le" || goarch == "arm64" || goarch == "s390x"
case "darwin":
return goarch == "amd64" || goarch == "arm64"
case "freebsd", "netbsd", "openbsd", "windows":
return goarch == "amd64"
default:
return false
}
}
// buildModeSupports is a copy of the function
// internal/platform.BuildModeSupported, which can't be used here
// because cmd/dist can not import internal packages during bootstrap.
func buildModeSupported(compiler, buildmode, goos, goarch string) bool {
if compiler == "gccgo" {
return true
}
platform := goos + "/" + goarch
switch buildmode {
case "archive":
return true
case "c-archive":
switch goos {
case "aix", "darwin", "ios", "windows":
return true
case "linux":
switch goarch {
case "386", "amd64", "arm", "armbe", "arm64", "arm64be", "ppc64le", "riscv64", "s390x":
// linux/ppc64 not supported because it does
// not support external linking mode yet.
return true
default:
// Other targets do not support -shared,
// per ParseFlags in
// cmd/compile/internal/base/flag.go.
// For c-archive the Go tool passes -shared,
// so that the result is suitable for inclusion
// in a PIE or shared library.
return false
}
case "freebsd":
return goarch == "amd64"
}
return false
case "c-shared":
switch platform {
case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/ppc64le", "linux/riscv64", "linux/s390x",
"android/amd64", "android/arm", "android/arm64", "android/386",
"freebsd/amd64",
"darwin/amd64", "darwin/arm64",
"windows/amd64", "windows/386", "windows/arm64":
return true
}
return false
case "default":
return true
case "exe":
return true
case "pie":
switch platform {
case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/riscv64", "linux/s390x",
"android/amd64", "android/arm", "android/arm64", "android/386",
"freebsd/amd64",
"darwin/amd64", "darwin/arm64",
"ios/amd64", "ios/arm64",
"aix/ppc64",
"windows/386", "windows/amd64", "windows/arm", "windows/arm64":
return true
}
return false
case "shared":
switch platform {
case "linux/386", "linux/amd64", "linux/arm", "linux/arm64", "linux/ppc64le", "linux/s390x":
return true
}
return false
case "plugin":
switch platform {
case "linux/amd64", "linux/arm", "linux/arm64", "linux/386", "linux/s390x", "linux/ppc64le",
"android/amd64", "android/386",
"darwin/amd64", "darwin/arm64",
"freebsd/amd64":
return true
}
return false
default:
return false
}
}
// isUnsupportedVMASize reports whether the failure is caused by an unsupported
// VMA for the race detector (for example, running the race detector on an
// arm64 machine configured with 39-bit VMA)
func isUnsupportedVMASize(w *work) bool {
unsupportedVMA := []byte("unsupported VMA range")
return w.dt.name == "race" && bytes.Contains(w.out, unsupportedVMA)
}
// isEnvSet reports whether the environment variable evar is
// set in the environment.
func isEnvSet(evar string) bool {
evarEq := evar + "="
for _, e := range os.Environ() {
if strings.HasPrefix(e, evarEq) {
return true
}
}
return false
}