| test: add runtarget action. |
| |
| --- test/fixedbugs/bug248.go |
| +++ test/fixedbugs/bug248.go |
| @@ -1,38 +1,57 @@ |
| // +build !nacl,!plan9,!windows |
| -// run |
| +// runtarget |
| |
| // Copyright 2009 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 ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(cmd ...string) { |
| + if *target == "" { |
| + run(cmd[0], cmd[1:]...) |
| + } else { |
| + run("go_"+*target+"_exec", cmd...) |
| + } |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| // TODO: If we get rid of errchk, re-enable this test on Windows. |
| errchk, err := filepath.Abs("errchk") |
| check(err) |
| |
| err = os.Chdir(filepath.Join("fixedbugs", "bug248.dir")) |
| check(err) |
| |
| - run("go", "tool", "compile", "bug0.go") |
| - run("go", "tool", "compile", "bug1.go") |
| - run("go", "tool", "compile", "bug2.go") |
| - run(errchk, "go", "tool", "compile", "-e", "bug3.go") |
| - run("go", "tool", "link", "bug2.o") |
| - run(fmt.Sprintf(".%ca.out", filepath.Separator)) |
| + run(goCmd(), "tool", "compile", "bug0.go") |
| + run(goCmd(), "tool", "compile", "bug1.go") |
| + run(goCmd(), "tool", "compile", "bug2.go") |
| + run(errchk, goCmd(), "tool", "compile", "-e", "bug3.go") |
| + run(goCmd(), "tool", "link", "bug2.o") |
| + goRun(fmt.Sprintf(".%ca.out", filepath.Separator)) |
| |
| os.Remove("bug0.o") |
| os.Remove("bug1.o") |
| os.Remove("bug2.o") |
| os.Remove("a.out") |
| } |
| |
| func run(name string, args ...string) { |
| --- test/fixedbugs/bug302.go |
| +++ test/fixedbugs/bug302.go |
| @@ -1,28 +1,39 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2010 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 ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func main() { |
| - run("go", "tool", "compile", filepath.Join("fixedbugs", "bug302.dir", "p.go")) |
| - run("go", "tool", "pack", "grc", "pp.a", "p.o") |
| - run("go", "tool", "compile", "-I", ".", filepath.Join("fixedbugs", "bug302.dir", "main.go")) |
| + flag.Parse() |
| + run(goCmd(), "tool", "compile", filepath.Join("fixedbugs", "bug302.dir", "p.go")) |
| + run(goCmd(), "tool", "pack", "grc", "pp.a", "p.o") |
| + run(goCmd(), "tool", "compile", "-I", ".", filepath.Join("fixedbugs", "bug302.dir", "main.go")) |
| os.Remove("p.o") |
| os.Remove("pp.a") |
| os.Remove("main.o") |
| } |
| |
| func run(cmd string, args ...string) { |
| out, err := exec.Command(cmd, args...).CombinedOutput() |
| if err != nil { |
| --- test/fixedbugs/bug345.go |
| +++ test/fixedbugs/bug345.go |
| @@ -1,34 +1,45 @@ |
| // +build !nacl,!plan9,!windows |
| -// run |
| +// runtarget |
| |
| // Copyright 2011 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 ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| // TODO: If we get rid of errchk, re-enable this test on Plan 9 and Windows. |
| errchk, err := filepath.Abs("errchk") |
| check(err) |
| |
| err = os.Chdir(filepath.Join(".", "fixedbugs", "bug345.dir")) |
| check(err) |
| |
| - run("go", "tool", "compile", "io.go") |
| - run(errchk, "go", "tool", "compile", "-e", "main.go") |
| + run(goCmd(), "tool", "compile", "io.go") |
| + run(errchk, goCmd(), "tool", "compile", "-e", "main.go") |
| os.Remove("io.o") |
| } |
| |
| func run(name string, args ...string) { |
| cmd := exec.Command(name, args...) |
| out, err := cmd.CombinedOutput() |
| if err != nil { |
| fmt.Println(string(out)) |
| --- test/fixedbugs/bug369.go |
| +++ test/fixedbugs/bug369.go |
| @@ -1,35 +1,54 @@ |
| // +build !nacl,!windows |
| -// run |
| +// runtarget |
| |
| // Copyright 2011 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. |
| |
| // Test that compiling with optimization turned on produces faster code. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(cmd ...string) { |
| + if *target == "" { |
| + run(cmd[0], cmd[1:]...) |
| + } else { |
| + run("go_"+*target+"_exec", cmd...) |
| + } |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| err := os.Chdir(filepath.Join(".", "fixedbugs", "bug369.dir")) |
| check(err) |
| |
| - run("go", "tool", "compile", "-N", "-o", "slow.o", "pkg.go") |
| - run("go", "tool", "compile", "-o", "fast.o", "pkg.go") |
| - run("go", "tool", "compile", "-o", "main.o", "main.go") |
| - run("go", "tool", "link", "-o", "a.exe", "main.o") |
| - run("." + string(filepath.Separator) + "a.exe") |
| + run(goCmd(), "tool", "compile", "-N", "-o", "slow.o", "pkg.go") |
| + run(goCmd(), "tool", "compile", "-o", "fast.o", "pkg.go") |
| + run(goCmd(), "tool", "compile", "-o", "main.o", "main.go") |
| + run(goCmd(), "tool", "link", "-o", "a.exe", "main.o") |
| + goRun("." + string(filepath.Separator) + "a.exe") |
| |
| os.Remove("slow.o") |
| os.Remove("fast.o") |
| os.Remove("main.o") |
| os.Remove("a.exe") |
| } |
| |
| func run(name string, args ...string) { |
| --- test/fixedbugs/bug429_run.go |
| +++ test/fixedbugs/bug429_run.go |
| @@ -1,29 +1,49 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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. |
| |
| // Run the bug429.go test. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(args ...string) *exec.Cmd { |
| + cmd := []string{"run"} |
| + if *target != "" { |
| + cmd = append(cmd, "-exec", "go_"+*target+"_exec") |
| + } |
| + cmd = append(cmd, args...) |
| + return exec.Command(goCmd(), cmd...) |
| +} |
| + |
| func main() { |
| - cmd := exec.Command("go", "run", filepath.Join("fixedbugs", "bug429.go")) |
| + flag.Parse() |
| + cmd := goRun(filepath.Join("fixedbugs", "bug429.go")) |
| out, err := cmd.CombinedOutput() |
| if err == nil { |
| fmt.Println("expected deadlock") |
| os.Exit(1) |
| } |
| |
| want := "fatal error: all goroutines are asleep - deadlock!" |
| got := string(out) |
| --- test/fixedbugs/issue10607.go |
| +++ test/fixedbugs/issue10607.go |
| @@ -1,31 +1,51 @@ |
| // +build linux,!ppc64 android |
| -// run |
| +// runtarget |
| |
| // 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. |
| |
| // Test that a -B option is passed through when using both internal |
| // and external linking mode. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(args ...string) *exec.Cmd { |
| + cmd := []string{"run"} |
| + if *target != "" { |
| + cmd = append(cmd, "-exec", "go_"+*target+"_exec") |
| + } |
| + cmd = append(cmd, args...) |
| + return exec.Command(goCmd(), cmd...) |
| +} |
| + |
| func main() { |
| - test("internal") |
| + flag.Parse() |
| + // test("internal") |
| test("external") |
| } |
| |
| func test(linkmode string) { |
| - out, err := exec.Command("go", "run", "-ldflags", "-B=0x12345678 -linkmode="+linkmode, filepath.Join("fixedbugs", "issue10607a.go")).CombinedOutput() |
| + out, err := goRun("-ldflags", "-B=0x12345678 -linkmode="+linkmode, filepath.Join("fixedbugs", "issue10607a.go")).CombinedOutput() |
| if err != nil { |
| fmt.Printf("BUG: linkmode=%s %v\n%s\n", linkmode, err, out) |
| os.Exit(1) |
| } |
| } |
| --- test/fixedbugs/issue11771.go |
| +++ test/fixedbugs/issue11771.go |
| @@ -1,31 +1,42 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // 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. |
| |
| // Issue 11771: Magic comments should ignore carriage returns. |
| |
| package main |
| |
| import ( |
| "bytes" |
| + "flag" |
| "fmt" |
| "io/ioutil" |
| "log" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "runtime" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| if runtime.Compiler != "gc" { |
| return |
| } |
| |
| dir, err := ioutil.TempDir("", "go-issue11771") |
| if err != nil { |
| log.Fatalf("creating temp dir: %v\n", err) |
| } |
| @@ -47,17 +58,17 @@ func main() { |
| func x() { |
| } |
| `) |
| |
| if err := ioutil.WriteFile(filepath.Join(dir, "x.go"), buf.Bytes(), 0666); err != nil { |
| log.Fatal(err) |
| } |
| |
| - cmd := exec.Command("go", "tool", "compile", "x.go") |
| + cmd := exec.Command(goCmd(), "tool", "compile", "x.go") |
| cmd.Dir = dir |
| output, err := cmd.CombinedOutput() |
| if err == nil { |
| log.Fatal("compile succeeded unexpectedly") |
| } |
| if !bytes.Contains(output, []byte("only allowed in runtime")) { |
| log.Fatalf("wrong error message from compiler; got:\n%s\n", output) |
| } |
| --- test/fixedbugs/issue9355.go |
| +++ test/fixedbugs/issue9355.go |
| @@ -1,34 +1,45 @@ |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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 ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "regexp" |
| "runtime" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| if runtime.Compiler != "gc" || runtime.GOOS == "nacl" { |
| return |
| } |
| |
| err := os.Chdir(filepath.Join("fixedbugs", "issue9355.dir")) |
| check(err) |
| |
| - out := run("go", "tool", "compile", "-S", "a.go") |
| + out := run(goCmd(), "tool", "compile", "-S", "a.go") |
| os.Remove("a.o") |
| |
| // 6g/8g print the offset as dec, but 5g/9g print the offset as hex. |
| patterns := []string{ |
| `rel 0\+\d t=1 \"\"\.x\+8\r?\n`, // y = &x.b |
| `rel 0\+\d t=1 \"\"\.x\+(28|1c)\r?\n`, // z = &x.d.q |
| `rel 0\+\d t=1 \"\"\.b\+5\r?\n`, // c = &b[5] |
| `rel 0\+\d t=1 \"\"\.x\+(88|58)\r?\n`, // w = &x.f[3].r |
| --- test/fixedbugs/issue9862_run.go |
| +++ test/fixedbugs/issue9862_run.go |
| @@ -1,26 +1,46 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // 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. |
| |
| // Check for compile or link error. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "os/exec" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(args ...string) *exec.Cmd { |
| + cmd := []string{"run"} |
| + if *target != "" { |
| + cmd = append(cmd, "-exec", "go_"+*target+"_exec") |
| + } |
| + cmd = append(cmd, args...) |
| + return exec.Command(goCmd(), cmd...) |
| +} |
| + |
| func main() { |
| - out, err := exec.Command("go", "run", "fixedbugs/issue9862.go").CombinedOutput() |
| + flag.Parse() |
| + out, err := goRun("fixedbugs/issue9862.go").CombinedOutput() |
| outstr := string(out) |
| if err == nil { |
| println("go run issue9862.go succeeded, should have failed\n", outstr) |
| return |
| } |
| if !strings.Contains(outstr, "symbol too large") { |
| println("go run issue9862.go gave unexpected error; want symbol too large:\n", outstr) |
| } |
| --- test/linkmain_run.go |
| +++ test/linkmain_run.go |
| @@ -1,26 +1,36 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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. |
| |
| // Run the sinit test. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func cleanup() { |
| os.Remove("linkmain.o") |
| os.Remove("linkmain.a") |
| os.Remove("linkmain1.o") |
| os.Remove("linkmain1.a") |
| os.Remove("linkmain.exe") |
| } |
| |
| @@ -46,21 +56,23 @@ func runFail(cmdline string) { |
| fmt.Println(string(out)) |
| fmt.Println("SHOULD HAVE FAILED!") |
| cleanup() |
| os.Exit(1) |
| } |
| } |
| |
| func main() { |
| + flag.Parse() |
| + |
| // helloworld.go is package main |
| - run("go tool compile -o linkmain.o helloworld.go") |
| - run("go tool compile -pack -o linkmain.a helloworld.go") |
| - run("go tool link -o linkmain.exe linkmain.o") |
| - run("go tool link -o linkmain.exe linkmain.a") |
| + run(goCmd() + " tool compile -o linkmain.o helloworld.go") |
| + run(goCmd() + " tool compile -pack -o linkmain.a helloworld.go") |
| + run(goCmd() + " tool link -o linkmain.exe linkmain.o") |
| + run(goCmd() + " tool link -o linkmain.exe linkmain.a") |
| |
| // linkmain.go is not |
| - run("go tool compile -o linkmain1.o linkmain.go") |
| - run("go tool compile -pack -o linkmain1.a linkmain.go") |
| - runFail("go tool link -o linkmain.exe linkmain1.o") |
| - runFail("go tool link -o linkmain.exe linkmain1.a") |
| + run(goCmd() + " tool compile -o linkmain1.o linkmain.go") |
| + run(goCmd() + " tool compile -pack -o linkmain1.a linkmain.go") |
| + runFail(goCmd() + " tool link -o linkmain.exe linkmain1.o") |
| + runFail(goCmd() + " tool link -o linkmain.exe linkmain1.a") |
| cleanup() |
| } |
| --- test/linkobj.go |
| +++ test/linkobj.go |
| @@ -1,31 +1,50 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2016 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. |
| |
| // Test the compiler -linkobj flag. |
| |
| package main |
| |
| import ( |
| + "flag" |
| "fmt" |
| "io/ioutil" |
| "log" |
| "os" |
| "os/exec" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(cmd ...string) string { |
| + if *target == "" { |
| + return run(cmd...) |
| + } else { |
| + return run(append([]string{"go_"+*target+"_exec"}, cmd...)...) |
| + } |
| +} |
| + |
| var pwd, tmpdir string |
| |
| func main() { |
| + flag.Parse() |
| dir, err := ioutil.TempDir("", "go-test-linkobj-") |
| if err != nil { |
| log.Fatal(err) |
| } |
| pwd, err = os.Getwd() |
| if err != nil { |
| log.Fatal(err) |
| } |
| @@ -71,33 +90,33 @@ func main() { |
| |
| // The compiler expects the files being read to have the right suffix. |
| o := "o" |
| if round == 1 { |
| o = "a" |
| } |
| |
| // inlining is disabled to make sure that the link objects contain needed code. |
| - run("go", "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p1."+o, "-linkobj", "p1.lo", "p1.go") |
| - run("go", "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p2."+o, "-linkobj", "p2.lo", "p2.go") |
| - run("go", "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p3."+o, "-linkobj", "p3.lo", "p3.go") |
| + run(goCmd(), "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p1."+o, "-linkobj", "p1.lo", "p1.go") |
| + run(goCmd(), "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p2."+o, "-linkobj", "p2.lo", "p2.go") |
| + run(goCmd(), "tool", "compile", pkg, "-D", ".", "-I", ".", "-l", "-o", "p3."+o, "-linkobj", "p3.lo", "p3.go") |
| |
| cp("p1."+o, "p1.oo") |
| cp("p2."+o, "p2.oo") |
| cp("p3."+o, "p3.oo") |
| cp("p1.lo", "p1."+o) |
| cp("p2.lo", "p2."+o) |
| cp("p3.lo", "p3."+o) |
| - out := runFail("go", "tool", "link", "p2."+o) |
| + out := runFail(goCmd(), "tool", "link", "p2."+o) |
| if !strings.Contains(out, "not package main") { |
| fatalf("link p2.o failed but not for package main:\n%s", out) |
| } |
| |
| - run("go", "tool", "link", "-L", ".", "-o", "a.out.exe", "p3."+o) |
| - out = run("./a.out.exe") |
| + run(goCmd(), "tool", "link", "-L", ".", "-o", "a.out.exe", "p3."+o) |
| + out = goRun("./a.out.exe") |
| if !strings.Contains(out, "hello from p1\nhello from p2\nhello from main\n") { |
| fatalf("running main, incorrect output:\n%s", out) |
| } |
| |
| // ensure that mistaken future round can't use these |
| os.Remove("p1.o") |
| os.Remove("a.out.exe") |
| } |
| --- test/linkx_run.go |
| +++ test/linkx_run.go |
| @@ -1,35 +1,55 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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. |
| |
| // Run the linkx test. |
| |
| package main |
| |
| import ( |
| "bytes" |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goRun(args ...string) *exec.Cmd { |
| + cmd := []string{"run"} |
| + if *target != "" { |
| + cmd = append(cmd, "-exec", "go_"+*target+"_exec") |
| + } |
| + cmd = append(cmd, args...) |
| + return exec.Command(goCmd(), cmd...) |
| +} |
| + |
| func main() { |
| + flag.Parse() |
| // test(" ") // old deprecated & removed syntax |
| test("=") // new syntax |
| } |
| |
| func test(sep string) { |
| // Successful run |
| - cmd := exec.Command("go", "run", "-ldflags=-X main.tbd"+sep+"hello -X main.overwrite"+sep+"trumped -X main.nosuchsymbol"+sep+"neverseen", "linkx.go") |
| + cmd := goRun("-ldflags=-X main.tbd"+sep+"hello -X main.overwrite"+sep+"trumped -X main.nosuchsymbol"+sep+"neverseen", "linkx.go") |
| var out, errbuf bytes.Buffer |
| cmd.Stdout = &out |
| cmd.Stderr = &errbuf |
| err := cmd.Run() |
| if err != nil { |
| fmt.Println(errbuf.String()) |
| fmt.Println(out.String()) |
| fmt.Println(err) |
| @@ -39,25 +59,25 @@ func test(sep string) { |
| want := "hello\ntrumped\n" |
| got := out.String() |
| if got != want { |
| fmt.Printf("got %q want %q\n", got, want) |
| os.Exit(1) |
| } |
| |
| // Issue 8810 |
| - cmd = exec.Command("go", "run", "-ldflags=-X main.tbd", "linkx.go") |
| + cmd = goRun("-ldflags=-X main.tbd", "linkx.go") |
| _, err = cmd.CombinedOutput() |
| if err == nil { |
| fmt.Println("-X linker flag should not accept keys without values") |
| os.Exit(1) |
| } |
| |
| // Issue 9621 |
| - cmd = exec.Command("go", "run", "-ldflags=-X main.b=false -X main.x=42", "linkx.go") |
| + cmd = goRun("-ldflags=-X main.b=false -X main.x=42", "linkx.go") |
| outx, err := cmd.CombinedOutput() |
| if err == nil { |
| fmt.Println("-X linker flag should not overwrite non-strings") |
| os.Exit(1) |
| } |
| outstr := string(outx) |
| if !strings.Contains(outstr, "main.b") { |
| fmt.Printf("-X linker flag did not diagnose overwrite of main.b:\n%s\n", outstr) |
| --- test/nosplit.go |
| +++ test/nosplit.go |
| @@ -1,31 +1,49 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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/ioutil" |
| "log" |
| "os" |
| "os/exec" |
| "path/filepath" |
| "regexp" |
| - "runtime" |
| "strconv" |
| "strings" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| +func goArch() string { |
| + goarch, err := exec.Command(goCmd(), "env", "GOARCH").Output() |
| + if err != nil { |
| + bug() |
| + fmt.Printf("running go env GOARCH: %v\n", err) |
| + } |
| + return strings.TrimSpace(string(goarch)) |
| +} |
| + |
| var tests = ` |
| # These are test cases for the linker analysis that detects chains of |
| # nosplit functions that would cause a stack overflow. |
| # |
| # Lines beginning with # are comments. |
| # |
| # Each test case describes a sequence of functions, one per line. |
| # Each function definition is the function name, then the frame size, |
| @@ -189,22 +207,23 @@ var ( |
| commentRE = regexp.MustCompile(`(?m)^#.*`) |
| rejectRE = regexp.MustCompile(`(?s)\A(.+?)((\n|; *)REJECT(.*))?\z`) |
| lineRE = regexp.MustCompile(`(\w+) (\d+)( nosplit)?(.*)`) |
| callRE = regexp.MustCompile(`\bcall (\w+)\b`) |
| callindRE = regexp.MustCompile(`\bcallind\b`) |
| ) |
| |
| func main() { |
| - goarch := os.Getenv("GOARCH") |
| + flag.Parse() |
| + goarch := goArch() |
| if goarch == "" { |
| - goarch = runtime.GOARCH |
| + return |
| } |
| |
| - version, err := exec.Command("go", "tool", "compile", "-V").Output() |
| + version, err := exec.Command(goCmd(), "tool", "compile", "-V").Output() |
| if err != nil { |
| bug() |
| fmt.Printf("running go tool compile -V: %v\n", err) |
| return |
| } |
| if s := string(version); goarch == "amd64" && strings.Contains(s, "X:") && !strings.Contains(s, "framepointer") { |
| // Skip this test if framepointer is NOT enabled on AMD64 |
| return |
| @@ -340,17 +359,17 @@ TestCases: |
| |
| if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil { |
| log.Fatal(err) |
| } |
| if err := ioutil.WriteFile(filepath.Join(dir, "main.go"), gobuf.Bytes(), 0666); err != nil { |
| log.Fatal(err) |
| } |
| |
| - cmd := exec.Command("go", "build") |
| + cmd := exec.Command(goCmd(), "build") |
| cmd.Dir = dir |
| output, err := cmd.CombinedOutput() |
| if err == nil { |
| nok++ |
| if reject { |
| bug() |
| fmt.Printf("accepted incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza))) |
| } |
| --- test/run.go |
| +++ test/run.go |
| @@ -222,16 +222,26 @@ func goRun(runcmd runCmd, flags []string, goname string, args ...string) (out [] |
| cmd = append(cmd, findExecCmd()...) |
| } |
| cmd = append(cmd, flags...) |
| cmd = append(cmd, goname) |
| cmd = append(cmd, args...) |
| return runcmd(cmd...) |
| } |
| |
| +func goRunTarget(runcmd runCmd, goname string, args ...string) (out []byte, err error) { |
| + cmd := []string{"go_local", "run"} |
| + cmd = append(cmd, goname) |
| + if *target != "" { |
| + cmd = append(cmd, "-target", *target) |
| + } |
| + cmd = append(cmd, args...) |
| + return runcmd(cmd...) |
| +} |
| + |
| // skipError describes why a test was skipped. |
| type skipError string |
| |
| func (s skipError) Error() string { return string(s) } |
| |
| func check(err error) { |
| if err != nil { |
| log.Fatal(err) |
| @@ -484,17 +494,17 @@ func (t *test) run() { |
| } |
| |
| // TODO: Clean up/simplify this switch statement. |
| switch action { |
| case "rundircmpout": |
| action = "rundir" |
| case "cmpout": |
| action = "run" // the run case already looks for <dir>/<test>.out files |
| - case "compile", "compiledir", "build", "builddir", "run", "buildrun", "runoutput", "rundir": |
| + case "compile", "compiledir", "build", "builddir", "run", "runtarget", "buildrun", "runoutput", "rundir": |
| // nothing to do |
| case "errorcheckandrundir": |
| wantError = false // should be no error if also will run |
| case "errorcheckwithauto": |
| action = "errorcheck" |
| wantAuto = true |
| wantError = true |
| case "errorcheck", "errorcheckdir", "errorcheckoutput": |
| @@ -807,16 +817,27 @@ func (t *test) run() { |
| if err != nil { |
| t.err = err |
| return |
| } |
| if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() { |
| t.err = fmt.Errorf("incorrect output\n%s", out) |
| } |
| |
| + case "runtarget": |
| + useTmp = false |
| + out, err := goRunTarget(runcmd, t.goFileName(), args...) |
| + if err != nil { |
| + t.err = err |
| + return |
| + } |
| + if strings.Replace(string(out), "\r\n", "\n", -1) != t.expectedOutput() { |
| + t.err = fmt.Errorf("incorrect output\n%s", out) |
| + } |
| + |
| case "runoutput": |
| rungatec <- true |
| defer func() { |
| <-rungatec |
| }() |
| useTmp = false |
| out, err := goRun(runcmd, nil, t.goFileName(), args...) |
| if err != nil { |
| --- test/sinit_run.go |
| +++ test/sinit_run.go |
| @@ -1,28 +1,39 @@ |
| // +build !nacl |
| -// run |
| +// runtarget |
| |
| // Copyright 2014 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. |
| |
| // Run the sinit test. |
| |
| package main |
| |
| import ( |
| "bytes" |
| + "flag" |
| "fmt" |
| "os" |
| "os/exec" |
| ) |
| |
| +var target = flag.String("target", "", "if non empty, use 'go_target' to compile test files and 'go_target_exec' to run the binaries") |
| + |
| +func goCmd() string { |
| + if *target != "" { |
| + return "go_" + *target |
| + } |
| + return "go" |
| +} |
| + |
| func main() { |
| - cmd := exec.Command("go", "tool", "compile", "-S", "sinit.go") |
| + flag.Parse() |
| + cmd := exec.Command(goCmd(), "tool", "compile", "-S", "sinit.go") |
| out, err := cmd.CombinedOutput() |
| if err != nil { |
| fmt.Println(string(out)) |
| fmt.Println(err) |
| os.Exit(1) |
| } |
| os.Remove("sinit.o") |
| |