diff options
Diffstat (limited to 'go/patch/go-1.10.3/go2.patch')
| -rw-r--r-- | go/patch/go-1.10.3/go2.patch | 267 |
1 files changed, 267 insertions, 0 deletions
diff --git a/go/patch/go-1.10.3/go2.patch b/go/patch/go-1.10.3/go2.patch new file mode 100644 index 00000000..bbd2b744 --- /dev/null +++ b/go/patch/go-1.10.3/go2.patch @@ -0,0 +1,267 @@ +diff --git test/run.go test/run.go +index 22ec7576f8..ac5d3c3e8d 100644 +--- test/run.go ++++ test/run.go +@@ -39,9 +39,9 @@ var ( + summary = flag.Bool("summary", false, "show summary of results") + showSkips = flag.Bool("show_skips", false, "show skipped tests") + runSkips = flag.Bool("run_skips", false, "run skipped tests (ignore skip and build tags)") +- linkshared = flag.Bool("linkshared", false, "") + updateErrors = flag.Bool("update_errors", false, "update error messages in test file based on compiler output") + runoutputLimit = flag.Int("l", defaultRunOutputLimit(), "number of parallel runoutput tests to run") ++ target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") + + shard = flag.Int("shard", 0, "shard index to run. Only applicable if -shards is non-zero.") + shards = flag.Int("shards", 0, "number of shards. If 0, all tests are run. This is used by the continuous build.") +@@ -194,21 +194,15 @@ func goFiles(dir string) []string { + type runCmd func(...string) ([]byte, error) + + func compileFile(runcmd runCmd, longname string, flags []string) (out []byte, err error) { +- cmd := []string{"go", "tool", "compile", "-e"} ++ cmd := []string{findGoCmd(), "tool", "compile", "-e"} + cmd = append(cmd, flags...) +- if *linkshared { +- cmd = append(cmd, "-dynlink", "-installsuffix=dynlink") +- } + cmd = append(cmd, longname) + return runcmd(cmd...) + } + + func compileInDir(runcmd runCmd, dir string, flags []string, names ...string) (out []byte, err error) { +- cmd := []string{"go", "tool", "compile", "-e", "-D", ".", "-I", "."} ++ cmd := []string{findGoCmd(), "tool", "compile", "-e", "-D", ".", "-I", "."} + cmd = append(cmd, flags...) +- if *linkshared { +- cmd = append(cmd, "-dynlink", "-installsuffix=dynlink") +- } + for _, name := range names { + cmd = append(cmd, filepath.Join(dir, name)) + } +@@ -217,15 +211,24 @@ func compileInDir(runcmd runCmd, dir string, flags []string, names ...string) (o + + func linkFile(runcmd runCmd, goname string) (err error) { + pfile := strings.Replace(goname, ".go", ".o", -1) +- cmd := []string{"go", "tool", "link", "-w", "-o", "a.exe", "-L", "."} +- if *linkshared { +- cmd = append(cmd, "-linkshared", "-installsuffix=dynlink") +- } +- cmd = append(cmd, pfile) +- _, err = runcmd(cmd...) ++ cmd := []string{findGoCmd, "tool", "link", "-w", "-o", "a.exe", "-L", "."} ++ _, err = runcmd(findGoCmd(), "tool", "link", "-w", "-o", "a.exe", "-L", ".", pfile) + return + } + ++ ++func goRun(runcmd runCmd, flags []string, goname string, args ...string) (out []byte, err error) { ++ cmd := []string{findGoCmd(), "run", goGcflags()} ++ if len(findExecCmd()) > 0 { ++ cmd = append(cmd, "-exec") ++ cmd = append(cmd, findExecCmd()...) ++ } ++ cmd = append(cmd, flags...) ++ cmd = append(cmd, goname) ++ cmd = append(cmd, args...) ++ return runcmd(cmd...) ++} ++ + // skipError describes why a test was skipped. + type skipError string + +@@ -595,7 +598,7 @@ func (t *test) run() { + + case "errorcheck": + // TODO(gri) remove need for -C (disable printing of columns in error messages) +- cmdline := []string{"go", "tool", "compile", "-C", "-e", "-o", "a.o"} ++ cmdline := []string{findGoCmd(), "tool", "compile", "-C", "-e", "-o", "a.o"} + // No need to add -dynlink even if linkshared if we're just checking for errors... + cmdline = append(cmdline, flags...) + cmdline = append(cmdline, long) +@@ -709,7 +712,7 @@ func (t *test) run() { + } + + case "build": +- _, err := runcmd("go", "build", goGcflags(), "-o", "a.exe", long) ++ _, err := runcmd(findGoCmd(), "build", goGcflags(), "-o", "a.exe", long) + if err != nil { + t.err = err + } +@@ -735,7 +738,7 @@ func (t *test) run() { + + } + var objs []string +- cmd := []string{"go", "tool", "compile", "-e", "-D", ".", "-I", ".", "-o", "go.o"} ++ cmd := []string{findGoCmd(), "tool", "compile", "-e", "-D", ".", "-I", ".", "-o", "go.o"} + if len(asms) > 0 { + cmd = append(cmd, "-asmhdr", "go_asm.h") + } +@@ -749,7 +752,7 @@ func (t *test) run() { + } + objs = append(objs, "go.o") + if len(asms) > 0 { +- cmd = []string{"go", "tool", "asm", "-e", "-I", ".", "-o", "asm.o"} ++ cmd = []string{findGoCmd(), "tool", "asm", "-e", "-I", ".", "-o", "asm.o"} + for _, file := range asms { + cmd = append(cmd, filepath.Join(longdir, file.Name())) + } +@@ -760,14 +763,14 @@ func (t *test) run() { + } + objs = append(objs, "asm.o") + } +- cmd = []string{"go", "tool", "pack", "c", "all.a"} ++ cmd = []string{findGoCmd(), "tool", "pack", "c", "all.a"} + cmd = append(cmd, objs...) + _, err = runcmd(cmd...) + if err != nil { + t.err = err + break + } +- cmd = []string{"go", "tool", "link", "all.a"} ++ cmd = []string{findGoCmd(), "tool", "link", "-o", "a.exe", "all.a"} + _, err = runcmd(cmd...) + if err != nil { + t.err = err +@@ -777,10 +780,7 @@ func (t *test) run() { + case "buildrun": // build binary, then run binary, instead of go run. Useful for timeout tests where failure mode is infinite loop. + // TODO: not supported on NaCl + useTmp = true +- cmd := []string{"go", "build", goGcflags(), "-o", "a.exe"} +- if *linkshared { +- cmd = append(cmd, "-linkshared") +- } ++ cmd := []string{findGoCmd(), "build", goGcflags(), "-o", "a.exe"} + longdirgofile := filepath.Join(filepath.Join(cwd, t.dir), t.gofile) + cmd = append(cmd, flags...) + cmd = append(cmd, longdirgofile) +@@ -789,7 +789,12 @@ func (t *test) run() { + t.err = err + return + } +- cmd = []string{"./a.exe"} ++ cmd = []string{} ++ if len(findExecCmd()) > 0 { ++ cmd = append(cmd, findExecCmd()...) ++ } ++ cmd = append(cmd, "./a.exe") ++ + out, err = runcmd(append(cmd, args...)...) + if err != nil { + t.err = err +@@ -802,38 +807,7 @@ func (t *test) run() { + + case "run": + useTmp = false +- var out []byte +- var err error +- if len(flags)+len(args) == 0 && goGcflags() == "" && !*linkshared { +- // If we're not using special go command flags, +- // skip all the go command machinery. +- // This avoids any time the go command would +- // spend checking whether, for example, the installed +- // package runtime is up to date. +- // Because we run lots of trivial test programs, +- // the time adds up. +- pkg := filepath.Join(t.tempDir, "pkg.a") +- if _, err := runcmd("go", "tool", "compile", "-o", pkg, t.goFileName()); err != nil { +- t.err = err +- return +- } +- exe := filepath.Join(t.tempDir, "test.exe") +- cmd := []string{"go", "tool", "link", "-s", "-w"} +- cmd = append(cmd, "-o", exe, pkg) +- if _, err := runcmd(cmd...); err != nil { +- t.err = err +- return +- } +- out, err = runcmd(append([]string{exe}, args...)...) +- } else { +- cmd := []string{"go", "run", goGcflags()} +- if *linkshared { +- cmd = append(cmd, "-linkshared") +- } +- cmd = append(cmd, flags...) +- cmd = append(cmd, t.goFileName()) +- out, err = runcmd(append(cmd, args...)...) +- } ++ out, err := goRun(runcmd, flags, t.goFileName(), args...) + if err != nil { + t.err = err + return +@@ -848,12 +822,7 @@ func (t *test) run() { + <-rungatec + }() + useTmp = false +- cmd := []string{"go", "run", goGcflags()} +- if *linkshared { +- cmd = append(cmd, "-linkshared") +- } +- cmd = append(cmd, t.goFileName()) +- out, err := runcmd(append(cmd, args...)...) ++ out, err := goRun(runcmd, nil, t.goFileName(), args...) + if err != nil { + t.err = err + return +@@ -863,12 +832,7 @@ func (t *test) run() { + t.err = fmt.Errorf("write tempfile:%s", err) + return + } +- cmd = []string{"go", "run", goGcflags()} +- if *linkshared { +- cmd = append(cmd, "-linkshared") +- } +- cmd = append(cmd, tfile) +- out, err = runcmd(cmd...) ++ out, err = goRun(runcmd, nil, tfile) + if err != nil { + t.err = err + return +@@ -879,12 +843,7 @@ func (t *test) run() { + + case "errorcheckoutput": + useTmp = false +- cmd := []string{"go", "run", goGcflags()} +- if *linkshared { +- cmd = append(cmd, "-linkshared") +- } +- cmd = append(cmd, t.goFileName()) +- out, err := runcmd(append(cmd, args...)...) ++ out, err := goRun(runcmd, nil, t.goFileName(), args...) + if err != nil { + t.err = err + return +@@ -895,7 +854,7 @@ func (t *test) run() { + t.err = fmt.Errorf("write tempfile:%s", err) + return + } +- cmdline := []string{"go", "tool", "compile", "-e", "-o", "a.o"} ++ cmdline := []string{findGoCmd(), "tool", "compile", "-e", "-o", "a.o"} + cmdline = append(cmdline, flags...) + cmdline = append(cmdline, tfile) + out, err = runcmd(cmdline...) +@@ -922,6 +881,11 @@ func findExecCmd() []string { + return execCmd + } + execCmd = []string{} // avoid work the second time ++ if *target != "" { ++ execCmd = []string{"go_" + *target + "_exec"} ++ return execCmd ++ } ++ + if goos == runtime.GOOS && goarch == runtime.GOARCH { + return execCmd + } +@@ -932,6 +896,14 @@ func findExecCmd() []string { + return execCmd + } + ++func findGoCmd() string { ++ if *target != "" { ++ return "go_" + *target ++ } ++ return "go" ++} ++ ++ + func (t *test) String() string { + return filepath.Join(t.dir, t.gofile) + } |