all: correct location of go tool

In general, there are no guarantee that `go` command exist on $PATH.
This CL tries to get `go` command from $GOROOT/bin instead.

There are three kinds of code we should handle:
    For normal code, the CL implements goCmd() or goCmdName().
    For unit tests, the CL uses testenv.GoTool() or testenv.GoToolPath().
    For integration tests, the CL sets PATH=$GOROOT/bin:$PATH in cmd/dist.

Note that make.bash sets PATH=$GOROOT/bin:$PATH in the build process.
So this change is only useful when we use toolchain manually.

Updates #21875

Change-Id: I963b9f22ea732dd735363ececde4cf94a5db5ca2
Reviewed-on: https://go-review.googlesource.com/64650
Run-TryBot: Ian Lance Taylor <iant@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Ian Lance Taylor <iant@golang.org>

diff --git a/src/cmd/api/goapi.go b/src/cmd/api/goapi.go
index 936f9e55115fe6da6967c87a16c0f5152cd5e9ce..8cc78c01ed46ac18edaddecdfc09e66faa47a762 100644 (file)
--- a/src/cmd/api/goapi.go
+++ b/src/cmd/api/goapi.go
@@ -27,6 +27,18 @@ import (
        "strings"
 )
 
+func goCmd() string {
+       var exeSuffix string
+       if runtime.GOOS == "windows" {
+               exeSuffix = ".exe"
+       }
+       path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
+       if _, err := os.Stat(path); err == nil {
+               return path
+       }
+       return "go"
+}
+
 // Flags
 var (
        checkFile  = flag.String("c", "", "optional comma-separated filename(s) to check API against")
@@ -127,7 +139,7 @@ func main() {
        if flag.NArg() > 0 {
                pkgNames = flag.Args()
        } else {
-               stds, err := exec.Command("go", "list", "std").Output()
+               stds, err := exec.Command(goCmd(), "list", "std").Output()
                if err != nil {
                        log.Fatal(err)
                }

diff --git a/src/cmd/api/goapi_test.go b/src/cmd/api/goapi_test.go
index 0d00f6a29778114665cfac7e8cd38abacd0ab8aa..3c4e50a21a305b5b79300dde8211760a90d65fd2 100644 (file)
--- a/src/cmd/api/goapi_test.go
+++ b/src/cmd/api/goapi_test.go
@@ -9,6 +9,7 @@ import (
        "flag"
        "fmt"
        "go/build"
+       "internal/testenv"
        "io/ioutil"
        "os"
        "os/exec"
@@ -163,7 +164,7 @@ func TestSkipInternal(t *testing.T) {
 }
 
 func BenchmarkAll(b *testing.B) {
-       stds, err := exec.Command("go", "list", "std").Output()
+       stds, err := exec.Command(testenv.GoToolPath(b), "list", "std").Output()
        if err != nil {
                b.Fatal(err)
        }

diff --git a/src/cmd/api/run.go b/src/cmd/api/run.go
index 20cddb704bf231f9630aa5e519e5b5fd2dd90126..219776cae40769995205571594fc104777a8f1f7 100644 (file)
--- a/src/cmd/api/run.go
+++ b/src/cmd/api/run.go
@@ -14,8 +14,21 @@ import (
        "os"
        "os/exec"
        "path/filepath"
+       "runtime"
 )
 
+func goCmd() string {
+       var exeSuffix string
+       if runtime.GOOS == "windows" {
+               exeSuffix = ".exe"
+       }
+       path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
+       if _, err := os.Stat(path); err == nil {
+               return path
+       }
+       return "go"
+}
+
 var goroot string
 
 func main() {
@@ -25,7 +38,7 @@ func main() {
                log.Fatal("No $GOROOT set.")
        }
 
-       out, err := exec.Command("go", "tool", "api",
+       out, err := exec.Command(goCmd(), "tool", "api",
                "-c", file("go1", "go1.1", "go1.2", "go1.3", "go1.4", "go1.5", "go1.6", "go1.7", "go1.8", "go1.9"),
                "-next", file("next"),
                "-except", file("except")).CombinedOutput()

diff --git a/src/cmd/dist/test.go b/src/cmd/dist/test.go
index e9b4ca0fb2f297fe5ae00e079123912079821049..ae7f25cad9c7b28c165a4d430cbab6888959e249 100644 (file)
--- a/src/cmd/dist/test.go
+++ b/src/cmd/dist/test.go
@@ -85,6 +85,14 @@ type distTest struct {
 }
 
 func (t *tester) run() {
+       var exeSuffix string
+       if goos == "windows" {
+               exeSuffix = ".exe"
+       }
+       if _, err := os.Stat(filepath.Join(gobin, "go"+exeSuffix)); err == nil {
+               os.Setenv("PATH", fmt.Sprintf("%s%c%s", gobin, os.PathListSeparator, os.Getenv("PATH")))
+       }
+
        slurp, err := exec.Command("go", "env", "CGO_ENABLED").Output()
        if err != nil {
                log.Fatalf("Error running go env CGO_ENABLED: %v", err)

diff --git a/src/cmd/go/go_test.go b/src/cmd/go/go_test.go
index eaa2d0f68d0543dcd3f42218e54a6eb7edd69333..1a47b720835956a8506e7319ee8bde1e9a9b5d11 100644 (file)
--- a/src/cmd/go/go_test.go
+++ b/src/cmd/go/go_test.go
@@ -91,20 +91,25 @@ func TestMain(m *testing.M) {
                if race.Enabled {
                        args = append(args, "-race")
                }
-               out, err := exec.Command("go", args...).CombinedOutput()
+               gotool, err := testenv.GoTool()
+               if err != nil {
+                       fmt.Fprintln(os.Stderr, err)
+                       os.Exit(2)
+               }
+               out, err := exec.Command(gotool, args...).CombinedOutput()
                if err != nil {
                        fmt.Fprintf(os.Stderr, "building testgo failed: %v\n%s", err, out)
                        os.Exit(2)
                }
 
-               out, err = exec.Command("go", "env", "GOROOT").CombinedOutput()
+               out, err = exec.Command(gotool, "env", "GOROOT").CombinedOutput()
                if err != nil {
                        fmt.Fprintf(os.Stderr, "could not find testing GOROOT: %v\n%s", err, out)
                        os.Exit(2)
                }
                testGOROOT = strings.TrimSpace(string(out))
 
-               out, err = exec.Command("go", "env", "CC").CombinedOutput()
+               out, err = exec.Command(gotool, "env", "CC").CombinedOutput()
                if err != nil {
                        fmt.Fprintf(os.Stderr, "could not find testing CC: %v\n%s", err, out)
                        os.Exit(2)

diff --git a/src/cmd/link/internal/ld/nooptcgolink_test.go b/src/cmd/link/internal/ld/nooptcgolink_test.go
index 1df29652b2016b81c4097cb32ac2e86332040035..e019a39bf7348c796d8a4c03b14e96918e9231d3 100644 (file)
--- a/src/cmd/link/internal/ld/nooptcgolink_test.go
+++ b/src/cmd/link/internal/ld/nooptcgolink_test.go
@@ -22,7 +22,7 @@ func TestNooptCgoBuild(t *testing.T) {
                t.Fatal(err)
        }
        defer os.RemoveAll(dir)
-       cmd := exec.Command("go", "build", "-gcflags=-N -l", "-o", filepath.Join(dir, "a.out"))
+       cmd := exec.Command(testenv.GoToolPath(t), "build", "-gcflags=-N -l", "-o", filepath.Join(dir, "a.out"))
        cmd.Dir = filepath.Join(runtime.GOROOT(), "src", "runtime", "testdata", "testprogcgo")
        out, err := cmd.CombinedOutput()
        if err != nil {

diff --git a/src/cmd/trace/pprof.go b/src/cmd/trace/pprof.go
index 40803ac5f99ebefbd6d290cd22003dc756d5506c..47be2a6d1c55e5c85328c3ec9b0e40bef0ee9678 100644 (file)
--- a/src/cmd/trace/pprof.go
+++ b/src/cmd/trace/pprof.go
@@ -15,10 +15,24 @@ import (
        "net/http"
        "os"
        "os/exec"
+       "path/filepath"
+       "runtime"
 
        "github.com/google/pprof/profile"
 )
 
+func goCmd() string {
+       var exeSuffix string
+       if runtime.GOOS == "windows" {
+               exeSuffix = ".exe"
+       }
+       path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
+       if _, err := os.Stat(path); err == nil {
+               return path
+       }
+       return "go"
+}
+
 func init() {
        http.HandleFunc("/io", serveSVGProfile(pprofIO))
        http.HandleFunc("/block", serveSVGProfile(pprofBlock))
@@ -147,7 +161,7 @@ func serveSVGProfile(prof func(w io.Writer) error) http.HandlerFunc {
                        return
                }
                svgFilename := blockf.Name() + ".svg"
-               if output, err := exec.Command("go", "tool", "pprof", "-svg", "-output", svgFilename, blockf.Name()).CombinedOutput(); err != nil {
+               if output, err := exec.Command(goCmd(), "tool", "pprof", "-svg", "-output", svgFilename, blockf.Name()).CombinedOutput(); err != nil {
                        http.Error(w, fmt.Sprintf("failed to execute go tool pprof: %v\n%s", err, output), http.StatusInternalServerError)
                        return
                }

diff --git a/src/internal/trace/parser.go b/src/internal/trace/parser.go
index 2e145129ebe37d06dfe06eecf5156982f362c387..a774bf14c96ae77c1e8719dfdb99192a42abf616 100644 (file)
--- a/src/internal/trace/parser.go
+++ b/src/internal/trace/parser.go
@@ -12,11 +12,25 @@ import (
        "math/rand"
        "os"
        "os/exec"
+       "path/filepath"
+       "runtime"
        "strconv"
        "strings"
        _ "unsafe"
 )
 
+func goCmd() string {
+       var exeSuffix string
+       if runtime.GOOS == "windows" {
+               exeSuffix = ".exe"
+       }
+       path := filepath.Join(runtime.GOROOT(), "bin", "go"+exeSuffix)
+       if _, err := os.Stat(path); err == nil {
+               return path
+       }
+       return "go"
+}
+
 // Event describes one event in the trace.
 type Event struct {
        Off   int       // offset in input file (for debugging and error reporting)
@@ -757,7 +771,7 @@ func symbolize(events []*Event, bin string) error {
        }
 
        // Start addr2line.
-       cmd := exec.Command("go", "tool", "addr2line", bin)
+       cmd := exec.Command(goCmd(), "tool", "addr2line", bin)
        in, err := cmd.StdinPipe()
        if err != nil {
                return fmt.Errorf("failed to pipe addr2line stdin: %v", err)

diff --git a/src/os/os_windows_test.go b/src/os/os_windows_test.go
index 04c4a4af3347ca7ee2694b6921db34ddc814640b..228fecedf88b47f917fa5368e834f99bc270fe2e 100644 (file)
--- a/src/os/os_windows_test.go
+++ b/src/os/os_windows_test.go
@@ -811,7 +811,7 @@ func main() {
        }
 
        exe := filepath.Join(tmpdir, "main.exe")
-       cmd := osexec.Command("go", "build", "-o", exe, src)
+       cmd := osexec.Command(testenv.GoToolPath(t), "build", "-o", exe, src)
        cmd.Dir = tmpdir
        out, err := cmd.CombinedOutput()
        if err != nil {

diff --git a/src/runtime/syscall_windows_test.go b/src/runtime/syscall_windows_test.go
index 3da154dfa8e7d521f87c5f29ec6cdd12ae9c1c32..f5b43a8e3ed53fc349a30774f965e8206fab94a1 100644 (file)
--- a/src/runtime/syscall_windows_test.go
+++ b/src/runtime/syscall_windows_test.go
@@ -1043,7 +1043,7 @@ func BenchmarkRunningGoProgram(b *testing.B) {
        }
 
        exe := filepath.Join(tmpdir, "main.exe")
-       cmd := exec.Command("go", "build", "-o", exe, src)
+       cmd := exec.Command(testenv.GoToolPath(b), "build", "-o", exe, src)
        cmd.Dir = tmpdir
        out, err := cmd.CombinedOutput()
        if err != nil {