languages/go
languages/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-09-04 15:34:21 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: make nosplit test invariant to ABI wrappers

Browse source 
Currently, the nosplit test disables ABI wrapper generation because it
generates a main.main in assembly, and so the ABI wrapper for calling
from runtime.main to main.main counts against the nosplit limit, which
cases some of the tests to fail.

Fix this by first entering ABI0 in a splittable context and then
calling from there into the test entry point, since this doesn't
introduce an ABI wrapper.

While we're here, this CL removes the test's check for the
framepointer experiment. That's now statically enabled, so it doesn't
appear in the experiment line, and enabling any other experiment
causes the test to think that the framepointer experiment *isn't*
enabled.

For #40724.

Change-Id: I6291eb9391f129779e726c5fc8c41b7b4a14eeb9
Reviewed-on: https://go-review.googlesource.com/c/go/+/302772
Trust: Austin Clements <austin@google.com>
Run-TryBot: Austin Clements <austin@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Reviewed-by: Than McIntosh <thanm@google.com>
This commit is contained in:
Austin Clements 2021-03-17 18:28:38 -04:00
parent af4388aee1
commit c71acbfe83
1 changed files with 88 additions and 90 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

178
test/nosplit.go
View file

@ -21,6 +21,8 @@ import (
"strings" "strings"
) )
const debug = false
var tests = ` var tests = `
# These are test cases for the linker analysis that detects chains of # These are test cases for the linker analysis that detects chains of
# nosplit functions that would cause a stack overflow. # nosplit functions that would cause a stack overflow.
@ -33,8 +35,8 @@ var tests = `
# The body is assembly code, with some shorthands. # The body is assembly code, with some shorthands.
# The shorthand 'call x' stands for CALL x(SB). # The shorthand 'call x' stands for CALL x(SB).
# The shorthand 'callind' stands for 'CALL R0', where R0 is a register. # The shorthand 'callind' stands for 'CALL R0', where R0 is a register.
# Each test case must define a function named main, and it must be first. # Each test case must define a function named start, and it must be first.
# That is, a line beginning "main " indicates the start of a new test case. # That is, a line beginning "start " indicates the start of a new test case.
# Within a stanza, ; can be used instead of \n to separate lines. # Within a stanza, ; can be used instead of \n to separate lines.
# #
# After the function definition, the test case ends with an optional # After the function definition, the test case ends with an optional
@ -46,41 +48,41 @@ var tests = `
# that are only 32-bit aligned. # that are only 32-bit aligned.
# Ordinary function should work # Ordinary function should work
main 0 start 0
# Large frame marked nosplit is always wrong. # Large frame marked nosplit is always wrong.
main 10000 nosplit start 10000 nosplit
REJECT REJECT
# Calling a large frame is okay. # Calling a large frame is okay.
main 0 call big start 0 call big
big 10000 big 10000
# But not if the frame is nosplit. # But not if the frame is nosplit.
main 0 call big start 0 call big
big 10000 nosplit big 10000 nosplit
REJECT REJECT
# Recursion is okay. # Recursion is okay.
main 0 call main start 0 call start
# Recursive nosplit runs out of space. # Recursive nosplit runs out of space.
main 0 nosplit call main start 0 nosplit call start
REJECT REJECT
# Chains of ordinary functions okay. # Chains of ordinary functions okay.
main 0 call f1 start 0 call f1
f1 80 call f2 f1 80 call f2
f2 80 f2 80
# Chains of nosplit must fit in the stack limit, 128 bytes. # Chains of nosplit must fit in the stack limit, 128 bytes.
main 0 call f1 start 0 call f1
f1 80 nosplit call f2 f1 80 nosplit call f2
f2 80 nosplit f2 80 nosplit
REJECT REJECT
# Larger chains. # Larger chains.
main 0 call f1 start 0 call f1
f1 16 call f2 f1 16 call f2
f2 16 call f3 f2 16 call f3
f3 16 call f4 f3 16 call f4
@ -91,7 +93,7 @@ f7 16 call f8
f8 16 call end f8 16 call end
end 1000 end 1000
main 0 call f1 start 0 call f1
f1 16 nosplit call f2 f1 16 nosplit call f2
f2 16 nosplit call f3 f2 16 nosplit call f3
f3 16 nosplit call f4 f3 16 nosplit call f4
@ -106,27 +108,27 @@ REJECT
# Test cases near the 128-byte limit. # Test cases near the 128-byte limit.
# Ordinary stack split frame is always okay. # Ordinary stack split frame is always okay.
main 112 start 112
main 116 start 116
main 120 start 120
main 124 start 124
main 128 start 128
main 132 start 132
main 136 start 136
# A nosplit leaf can use the whole 128-CallSize bytes available on entry. # A nosplit leaf can use the whole 128-CallSize bytes available on entry.
# (CallSize is 32 on ppc64, 8 on amd64 for frame pointer.) # (CallSize is 32 on ppc64, 8 on amd64 for frame pointer.)
main 96 nosplit start 96 nosplit
main 100 nosplit; REJECT ppc64 ppc64le start 100 nosplit; REJECT ppc64 ppc64le
main 104 nosplit; REJECT ppc64 ppc64le arm64 start 104 nosplit; REJECT ppc64 ppc64le arm64
main 108 nosplit; REJECT ppc64 ppc64le start 108 nosplit; REJECT ppc64 ppc64le
main 112 nosplit; REJECT ppc64 ppc64le arm64 start 112 nosplit; REJECT ppc64 ppc64le arm64
main 116 nosplit; REJECT ppc64 ppc64le start 116 nosplit; REJECT ppc64 ppc64le
main 120 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 120 nosplit; REJECT ppc64 ppc64le amd64 arm64
main 124 nosplit; REJECT ppc64 ppc64le amd64 start 124 nosplit; REJECT ppc64 ppc64le amd64
main 128 nosplit; REJECT start 128 nosplit; REJECT
main 132 nosplit; REJECT start 132 nosplit; REJECT
main 136 nosplit; REJECT start 136 nosplit; REJECT
# Calling a nosplit function from a nosplit function requires # Calling a nosplit function from a nosplit function requires
# having room for the saved caller PC and the called frame. # having room for the saved caller PC and the called frame.
@ -134,55 +136,55 @@ main 136 nosplit; REJECT
# Because arm64 doesn't save LR in the leaf, it gets an extra 8 bytes. # Because arm64 doesn't save LR in the leaf, it gets an extra 8 bytes.
# ppc64 doesn't save LR in the leaf, but CallSize is 32, so it gets 24 bytes. # ppc64 doesn't save LR in the leaf, but CallSize is 32, so it gets 24 bytes.
# Because AMD64 uses frame pointer, it has 8 fewer bytes. # Because AMD64 uses frame pointer, it has 8 fewer bytes.
main 96 nosplit call f; f 0 nosplit start 96 nosplit call f; f 0 nosplit
main 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le start 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
main 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64 start 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64
main 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le start 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
main 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
main 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 start 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64
main 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64 start 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
main 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386 start 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386
main 128 nosplit call f; f 0 nosplit; REJECT start 128 nosplit call f; f 0 nosplit; REJECT
main 132 nosplit call f; f 0 nosplit; REJECT start 132 nosplit call f; f 0 nosplit; REJECT
main 136 nosplit call f; f 0 nosplit; REJECT start 136 nosplit call f; f 0 nosplit; REJECT
# Calling a splitting function from a nosplit function requires # Calling a splitting function from a nosplit function requires
# having room for the saved caller PC of the call but also the # having room for the saved caller PC of the call but also the
# saved caller PC for the call to morestack. # saved caller PC for the call to morestack.
# Architectures differ in the same way as before. # Architectures differ in the same way as before.
main 96 nosplit call f; f 0 call f start 96 nosplit call f; f 0 call f
main 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le start 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le
main 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64 start 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
main 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 start 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
main 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64 start 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
main 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 start 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
main 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64 start 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64
main 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 start 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386
main 128 nosplit call f; f 0 call f; REJECT start 128 nosplit call f; f 0 call f; REJECT
main 132 nosplit call f; f 0 call f; REJECT start 132 nosplit call f; f 0 call f; REJECT
main 136 nosplit call f; f 0 call f; REJECT start 136 nosplit call f; f 0 call f; REJECT
# Indirect calls are assumed to be splitting functions. # Indirect calls are assumed to be splitting functions.
main 96 nosplit callind start 96 nosplit callind
main 100 nosplit callind; REJECT ppc64 ppc64le start 100 nosplit callind; REJECT ppc64 ppc64le
main 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64 start 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
main 108 nosplit callind; REJECT ppc64 ppc64le amd64 start 108 nosplit callind; REJECT ppc64 ppc64le amd64
main 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64 start 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
main 116 nosplit callind; REJECT ppc64 ppc64le amd64 start 116 nosplit callind; REJECT ppc64 ppc64le amd64
main 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64 start 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64
main 124 nosplit callind; REJECT ppc64 ppc64le amd64 386 start 124 nosplit callind; REJECT ppc64 ppc64le amd64 386
main 128 nosplit callind; REJECT start 128 nosplit callind; REJECT
main 132 nosplit callind; REJECT start 132 nosplit callind; REJECT
main 136 nosplit callind; REJECT start 136 nosplit callind; REJECT
# Issue 7623 # Issue 7623
main 0 call f; f 112 start 0 call f; f 112
main 0 call f; f 116 start 0 call f; f 116
main 0 call f; f 120 start 0 call f; f 120
main 0 call f; f 124 start 0 call f; f 124
main 0 call f; f 128 start 0 call f; f 128
main 0 call f; f 132 start 0 call f; f 132
main 0 call f; f 136 start 0 call f; f 136
` `
var ( var (
@ -199,17 +201,6 @@ func main() {
goarch = runtime.GOARCH goarch = runtime.GOARCH
} }
version, err := exec.Command("go", "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
}
dir, err := ioutil.TempDir("", "go-test-nosplit") dir, err := ioutil.TempDir("", "go-test-nosplit")
if err != nil { if err != nil {
bug() bug()
@ -231,7 +222,7 @@ func main() {
TestCases: TestCases:
for len(tests) > 0 { for len(tests) > 0 {
var stanza string var stanza string
i := strings.Index(tests, "\nmain ") i := strings.Index(tests, "\nstart ")
if i < 0 { if i < 0 {
stanza, tests = tests, "" stanza, tests = tests, ""
} else { } else {
@ -293,6 +284,14 @@ TestCases:
fmt.Fprintf(&buf, "#define REGISTER AX\n") fmt.Fprintf(&buf, "#define REGISTER AX\n")
} }
// Since all of the functions we're generating are
// ABI0, first enter ABI0 via a splittable function
// and then go to the chain we're testing. This way we
// don't have to account for ABI wrappers in the chain.
fmt.Fprintf(&gobuf, "func main0()\n")
fmt.Fprintf(&gobuf, "func main() { main0() }\n")
fmt.Fprintf(&buf, "TEXT ·main0(SB),0,$0-0\n\tCALL ·start(SB)\n")
for _, line := range strings.Split(lines, "\n") { for _, line := range strings.Split(lines, "\n") {
line = strings.TrimSpace(line) line = strings.TrimSpace(line)
if line == "" { if line == "" {
@ -346,6 +345,12 @@ TestCases:
} }
} }
if debug {
fmt.Printf("===\n%s\n", strings.TrimSpace(stanza))
fmt.Printf("-- main.go --\n%s", gobuf.String())
fmt.Printf("-- asm.s --\n%s", buf.String())
}
if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil { if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil {
log.Fatal(err) log.Fatal(err)
} }
@ -353,14 +358,7 @@ TestCases:
log.Fatal(err) log.Fatal(err)
} }
// Turn off ABI0 wrapper generation for now. The problem here is cmd := exec.Command("go", "build")
// that in these test cases main.main is an assembly routine,
// thus calls to it will have to go through an ABI wrapper. The
// ABI wrapper will consume some stack space, which throws off
// the numbers.
workaround := "-gcflags=-abiwrap=0"
cmd := exec.Command("go", "build", workaround)
cmd.Dir = dir cmd.Dir = dir
output, err := cmd.CombinedOutput() output, err := cmd.CombinedOutput()
if err == nil { if err == nil {