mirror of
https://github.com/golang/go
synced 2024-09-29 05:14:29 -06:00
120f445495
The nosplit test was originally written when the stack limit was a mere 128 bytes. Now it's much larger, but rather than rewriting all of the tests, we apply a hack to just add the extra space into the stack frames of the existing tests. Unfortunately, we add it in the wrong place. The extra space should be added just once per chain of nosplit functions, but instead we add it to every frame that appears first on a line in the test's little script language. This means that for tests like start 0 call f1 f1 16 nosplit call f2 f2 16 nosplit call f3 f3 16 nosplit call f4 f4 16 nosplit call f5 f5 16 nosplit call f6 f6 16 nosplit call f7 f7 16 nosplit call f8 f8 16 nosplit call end end 1000 REJECT we add 672 bytes to *every* frame, meaning that we wind up way over the stack limit by the end of the stanza, rather than just a little as originally intended. Fix this by instead adding the extra space to the first nosplit function in a stanza. This isn't perfect either, since we could have a nosplit -> split -> nosplit chain, but it's the best we can do without a graph analysis. Change-Id: Ibf156c68fe3eb1b64a438115f4a17f1a6c7e2bd1 Reviewed-on: https://go-review.googlesource.com/c/go/+/398174 Run-TryBot: Austin Clements <austin@google.com> Reviewed-by: Cherry Mui <cherryyz@google.com> TryBot-Result: Gopher Robot <gobot@golang.org>
402 lines
11 KiB
Go
402 lines
11 KiB
Go
// +build !nacl,!js,!aix,!gcflags_noopt,gc
|
|
// run
|
|
|
|
// 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"
|
|
"fmt"
|
|
"io/ioutil"
|
|
"log"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"regexp"
|
|
"runtime"
|
|
"strconv"
|
|
"strings"
|
|
)
|
|
|
|
const debug = false
|
|
|
|
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,
|
|
# then optionally the keyword 'nosplit', then the body of the function.
|
|
# The body is assembly code, with some shorthands.
|
|
# The shorthand 'call x' stands for CALL x(SB).
|
|
# The shorthand 'callind' stands for 'CALL R0', where R0 is a register.
|
|
# Each test case must define a function named start, and it must be first.
|
|
# 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.
|
|
#
|
|
# After the function definition, the test case ends with an optional
|
|
# REJECT line, specifying the architectures on which the case should
|
|
# be rejected. "REJECT" without any architectures means reject on all architectures.
|
|
# The linker should accept the test case on systems not explicitly rejected.
|
|
#
|
|
# 64-bit systems do not attempt to execute test cases with frame sizes
|
|
# that are only 32-bit aligned.
|
|
|
|
# Ordinary function should work
|
|
start 0
|
|
|
|
# Large frame marked nosplit is always wrong.
|
|
start 10000 nosplit
|
|
REJECT
|
|
|
|
# Calling a large frame is okay.
|
|
start 0 call big
|
|
big 10000
|
|
|
|
# But not if the frame is nosplit.
|
|
start 0 call big
|
|
big 10000 nosplit
|
|
REJECT
|
|
|
|
# Recursion is okay.
|
|
start 0 call start
|
|
|
|
# Recursive nosplit runs out of space.
|
|
start 0 nosplit call start
|
|
REJECT
|
|
|
|
# Chains of ordinary functions okay.
|
|
start 0 call f1
|
|
f1 80 call f2
|
|
f2 80
|
|
|
|
# Chains of nosplit must fit in the stack limit, 128 bytes.
|
|
start 0 call f1
|
|
f1 80 nosplit call f2
|
|
f2 80 nosplit
|
|
REJECT
|
|
|
|
# Larger chains.
|
|
start 0 call f1
|
|
f1 16 call f2
|
|
f2 16 call f3
|
|
f3 16 call f4
|
|
f4 16 call f5
|
|
f5 16 call f6
|
|
f6 16 call f7
|
|
f7 16 call f8
|
|
f8 16 call end
|
|
end 1000
|
|
|
|
start 0 call f1
|
|
f1 16 nosplit call f2
|
|
f2 16 nosplit call f3
|
|
f3 16 nosplit call f4
|
|
f4 16 nosplit call f5
|
|
f5 16 nosplit call f6
|
|
f6 16 nosplit call f7
|
|
f7 16 nosplit call f8
|
|
f8 16 nosplit call end
|
|
end 1000
|
|
REJECT
|
|
|
|
# Test cases near the 128-byte limit.
|
|
|
|
# Ordinary stack split frame is always okay.
|
|
start 112
|
|
start 116
|
|
start 120
|
|
start 124
|
|
start 128
|
|
start 132
|
|
start 136
|
|
|
|
# A nosplit leaf can use the whole 128-CallSize bytes available on entry.
|
|
# (CallSize is 32 on ppc64, 8 on amd64 for frame pointer.)
|
|
start 96 nosplit
|
|
start 100 nosplit; REJECT ppc64 ppc64le
|
|
start 104 nosplit; REJECT ppc64 ppc64le arm64
|
|
start 108 nosplit; REJECT ppc64 ppc64le
|
|
start 112 nosplit; REJECT ppc64 ppc64le arm64
|
|
start 116 nosplit; REJECT ppc64 ppc64le
|
|
start 120 nosplit; REJECT ppc64 ppc64le amd64 arm64
|
|
start 124 nosplit; REJECT ppc64 ppc64le amd64
|
|
start 128 nosplit; REJECT
|
|
start 132 nosplit; REJECT
|
|
start 136 nosplit; REJECT
|
|
|
|
# Calling a nosplit function from a nosplit function requires
|
|
# having room for the saved caller PC and the called frame.
|
|
# Because ARM doesn't save LR in the leaf, it gets an extra 4 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.
|
|
# Because AMD64 uses frame pointer, it has 8 fewer bytes.
|
|
start 96 nosplit call f; f 0 nosplit
|
|
start 100 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
|
|
start 104 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le arm64
|
|
start 108 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le
|
|
start 112 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
|
|
start 116 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64
|
|
start 120 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 arm64
|
|
start 124 nosplit call f; f 0 nosplit; REJECT ppc64 ppc64le amd64 386
|
|
start 128 nosplit call f; f 0 nosplit; REJECT
|
|
start 132 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
|
|
# having room for the saved caller PC of the call but also the
|
|
# saved caller PC for the call to morestack.
|
|
# Architectures differ in the same way as before.
|
|
start 96 nosplit call f; f 0 call f
|
|
start 100 nosplit call f; f 0 call f; REJECT ppc64 ppc64le
|
|
start 104 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
|
|
start 108 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
|
|
start 112 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 arm64
|
|
start 116 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64
|
|
start 120 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386 arm64
|
|
start 124 nosplit call f; f 0 call f; REJECT ppc64 ppc64le amd64 386
|
|
start 128 nosplit call f; f 0 call f; REJECT
|
|
start 132 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.
|
|
start 96 nosplit callind
|
|
start 100 nosplit callind; REJECT ppc64 ppc64le
|
|
start 104 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
|
|
start 108 nosplit callind; REJECT ppc64 ppc64le amd64
|
|
start 112 nosplit callind; REJECT ppc64 ppc64le amd64 arm64
|
|
start 116 nosplit callind; REJECT ppc64 ppc64le amd64
|
|
start 120 nosplit callind; REJECT ppc64 ppc64le amd64 386 arm64
|
|
start 124 nosplit callind; REJECT ppc64 ppc64le amd64 386
|
|
start 128 nosplit callind; REJECT
|
|
start 132 nosplit callind; REJECT
|
|
start 136 nosplit callind; REJECT
|
|
|
|
# Issue 7623
|
|
start 0 call f; f 112
|
|
start 0 call f; f 116
|
|
start 0 call f; f 120
|
|
start 0 call f; f 124
|
|
start 0 call f; f 128
|
|
start 0 call f; f 132
|
|
start 0 call f; f 136
|
|
`
|
|
|
|
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")
|
|
if goarch == "" {
|
|
goarch = runtime.GOARCH
|
|
}
|
|
|
|
dir, err := ioutil.TempDir("", "go-test-nosplit")
|
|
if err != nil {
|
|
bug()
|
|
fmt.Printf("creating temp dir: %v\n", err)
|
|
return
|
|
}
|
|
defer os.RemoveAll(dir)
|
|
os.Setenv("GOPATH", filepath.Join(dir, "_gopath"))
|
|
|
|
if err := ioutil.WriteFile(filepath.Join(dir, "go.mod"), []byte("module go-test-nosplit\n"), 0666); err != nil {
|
|
log.Panic(err)
|
|
}
|
|
|
|
tests = strings.Replace(tests, "\t", " ", -1)
|
|
tests = commentRE.ReplaceAllString(tests, "")
|
|
|
|
nok := 0
|
|
nfail := 0
|
|
TestCases:
|
|
for len(tests) > 0 {
|
|
var stanza string
|
|
i := strings.Index(tests, "\nstart ")
|
|
if i < 0 {
|
|
stanza, tests = tests, ""
|
|
} else {
|
|
stanza, tests = tests[:i], tests[i+1:]
|
|
}
|
|
|
|
m := rejectRE.FindStringSubmatch(stanza)
|
|
if m == nil {
|
|
bug()
|
|
fmt.Printf("invalid stanza:\n\t%s\n", indent(stanza))
|
|
continue
|
|
}
|
|
lines := strings.TrimSpace(m[1])
|
|
reject := false
|
|
if m[2] != "" {
|
|
if strings.TrimSpace(m[4]) == "" {
|
|
reject = true
|
|
} else {
|
|
for _, rej := range strings.Fields(m[4]) {
|
|
if rej == goarch {
|
|
reject = true
|
|
}
|
|
}
|
|
}
|
|
}
|
|
if lines == "" && !reject {
|
|
continue
|
|
}
|
|
|
|
var gobuf bytes.Buffer
|
|
fmt.Fprintf(&gobuf, "package main\n")
|
|
|
|
var buf bytes.Buffer
|
|
ptrSize := 4
|
|
switch goarch {
|
|
case "mips", "mipsle":
|
|
fmt.Fprintf(&buf, "#define REGISTER (R0)\n")
|
|
case "mips64", "mips64le":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER (R0)\n")
|
|
case "ppc64", "ppc64le":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER (CTR)\n")
|
|
case "arm":
|
|
fmt.Fprintf(&buf, "#define REGISTER (R0)\n")
|
|
case "arm64":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER (R0)\n")
|
|
case "amd64":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER AX\n")
|
|
case "riscv64":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER A0\n")
|
|
case "s390x":
|
|
ptrSize = 8
|
|
fmt.Fprintf(&buf, "#define REGISTER R10\n")
|
|
default:
|
|
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")
|
|
|
|
adjusted := false
|
|
for _, line := range strings.Split(lines, "\n") {
|
|
line = strings.TrimSpace(line)
|
|
if line == "" {
|
|
continue
|
|
}
|
|
for _, subline := range strings.Split(line, ";") {
|
|
subline = strings.TrimSpace(subline)
|
|
if subline == "" {
|
|
continue
|
|
}
|
|
m := lineRE.FindStringSubmatch(subline)
|
|
if m == nil {
|
|
bug()
|
|
fmt.Printf("invalid function line: %s\n", subline)
|
|
continue TestCases
|
|
}
|
|
name := m[1]
|
|
size, _ := strconv.Atoi(m[2])
|
|
|
|
if size%ptrSize == 4 {
|
|
continue TestCases
|
|
}
|
|
nosplit := m[3]
|
|
body := m[4]
|
|
|
|
// The limit was originally 128 but is now 800 (928-128).
|
|
// Instead of rewriting the test cases above, adjust
|
|
// the first nosplit frame to use up the extra bytes.
|
|
// This isn't exactly right because we could have
|
|
// nosplit -> split -> nosplit, but it's good enough.
|
|
if !adjusted && nosplit != "" {
|
|
adjusted = true
|
|
size += (928 - 128) - 128
|
|
// Noopt builds have a larger stackguard.
|
|
// See ../src/cmd/dist/buildruntime.go:stackGuardMultiplier
|
|
// This increase is included in objabi.StackGuard
|
|
for _, s := range strings.Split(os.Getenv("GO_GCFLAGS"), " ") {
|
|
if s == "-N" {
|
|
size += 928
|
|
}
|
|
}
|
|
}
|
|
|
|
if nosplit != "" {
|
|
nosplit = ",7"
|
|
} else {
|
|
nosplit = ",0"
|
|
}
|
|
body = callRE.ReplaceAllString(body, "CALL ·$1(SB);")
|
|
body = callindRE.ReplaceAllString(body, "CALL REGISTER;")
|
|
|
|
fmt.Fprintf(&gobuf, "func %s()\n", name)
|
|
fmt.Fprintf(&buf, "TEXT ·%s(SB)%s,$%d-0\n\t%s\n\tRET\n\n", name, nosplit, size, body)
|
|
}
|
|
}
|
|
|
|
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 {
|
|
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.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)))
|
|
}
|
|
} else {
|
|
nfail++
|
|
if !reject {
|
|
bug()
|
|
fmt.Printf("rejected incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza)))
|
|
fmt.Printf("\n\tlinker output:\n\t%s\n", indent(string(output)))
|
|
}
|
|
}
|
|
}
|
|
|
|
if !bugged && (nok == 0 || nfail == 0) {
|
|
bug()
|
|
fmt.Printf("not enough test cases run\n")
|
|
}
|
|
}
|
|
|
|
func indent(s string) string {
|
|
return strings.Replace(s, "\n", "\n\t", -1)
|
|
}
|
|
|
|
var bugged = false
|
|
|
|
func bug() {
|
|
if !bugged {
|
|
bugged = true
|
|
fmt.Printf("BUG\n")
|
|
}
|
|
}
|