You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
981 lines
25 KiB
981 lines
25 KiB
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")
|
|
|