test/nosplit.go

   1 // run
   2
   3 // +build !nacl
   4
   5 // Copyright 2014 The Go Authors.  All rights reserved.
   6 // Use of this source code is governed by a BSD-style
   7 // license that can be found in the LICENSE file.
   8
   9 package main
  10
  11 import (
  12         "bytes"
  13         "fmt"
  14         "io/ioutil"
  15         "log"
  16         "os"
  17         "os/exec"
  18         "path/filepath"
  19         "regexp"
  20         "runtime"
  21         "strconv"
  22         "strings"
  23 )
  24
  25 var tests = `
  26 # These are test cases for the linker analysis that detects chains of
  27 # nosplit functions that would cause a stack overflow.
  28 #
  29 # Lines beginning with # are comments.
  30 #
  31 # Each test case describes a sequence of functions, one per line.
  32 # Each function definition is the function name, then the frame size,
  33 # then optionally the keyword 'nosplit', then the body of the function.
  34 # The body is assembly code, with some shorthands.
  35 # The shorthand 'call x' stands for CALL x(SB).
  36 # The shorthand 'callind' stands for 'CALL R0', where R0 is a register.
  37 # Each test case must define a function named main, and it must be first.
  38 # That is, a line beginning "main " indicates the start of a new test case.
  39 # Within a stanza, ; can be used instead of \n to separate lines.
  40 #
  41 # After the function definition, the test case ends with an optional
  42 # REJECT line, specifying the architectures on which the case should
  43 # be rejected. "REJECT" without any architectures means reject on all architectures.
  44 # The linker should accept the test case on systems not explicitly rejected.
  45 #
  46 # 64-bit systems do not attempt to execute test cases with frame sizes
  47 # that are only 32-bit aligned.
  48
  49 # Ordinary function should work
  50 main 0
  51
  52 # Large frame marked nosplit is always wrong.
  53 main 10000 nosplit
  54 REJECT
  55
  56 # Calling a large frame is okay.
  57 main 0 call big
  58 big 10000
  59
  60 # But not if the frame is nosplit.
  61 main 0 call big
  62 big 10000 nosplit
  63 REJECT
  64
  65 # Recursion is okay.
  66 main 0 call main
  67
  68 # Recursive nosplit runs out of space.
  69 main 0 nosplit call main
  70 REJECT
  71
  72 # Chains of ordinary functions okay.
  73 main 0 call f1
  74 f1 80 call f2
  75 f2 80
  76
  77 # Chains of nosplit must fit in the stack limit, 128 bytes.
  78 main 0 call f1
  79 f1 80 nosplit call f2
  80 f2 80 nosplit
  81 REJECT
  82
  83 # Larger chains.
  84 main 0 call f1
  85 f1 16 call f2
  86 f2 16 call f3
  87 f3 16 call f4
  88 f4 16 call f5
  89 f5 16 call f6
  90 f6 16 call f7
  91 f7 16 call f8
  92 f8 16 call end
  93 end 1000
  94
  95 main 0 call f1
  96 f1 16 nosplit call f2
  97 f2 16 nosplit call f3
  98 f3 16 nosplit call f4
  99 f4 16 nosplit call f5
 100 f5 16 nosplit call f6
 101 f6 16 nosplit call f7
 102 f7 16 nosplit call f8
 103 f8 16 nosplit call end
 104 end 1000
 105 REJECT
 106
 107 # Test cases near the 128-byte limit.
 108
 109 # Ordinary stack split frame is always okay.
 110 main 112
 111 main 116
 112 main 120
 113 main 124
 114 main 128
 115 main 132
 116 main 136
 117
 118 # A nosplit leaf can use the whole 128-CallSize bytes available on entry.
 119 main 112 nosplit
 120 main 116 nosplit
 121 main 120 nosplit
 122 main 124 nosplit
 123 main 128 nosplit; REJECT
 124 main 132 nosplit; REJECT
 125 main 136 nosplit; REJECT
 126
 127 # Calling a nosplit function from a nosplit function requires
 128 # having room for the saved caller PC and the called frame.
 129 # Because ARM doesn't save LR in the leaf, it gets an extra 4 bytes.
 130 # Because ppc64 doesn't save LR in the leaf, it gets an extra 8 bytes.
 131 main 112 nosplit call f; f 0 nosplit
 132 main 116 nosplit call f; f 0 nosplit
 133 main 120 nosplit call f; f 0 nosplit; REJECT amd64
 134 main 124 nosplit call f; f 0 nosplit; REJECT amd64 386
 135 main 128 nosplit call f; f 0 nosplit; REJECT
 136 main 132 nosplit call f; f 0 nosplit; REJECT
 137 main 136 nosplit call f; f 0 nosplit; REJECT
 138
 139 # Calling a splitting function from a nosplit function requires
 140 # having room for the saved caller PC of the call but also the
 141 # saved caller PC for the call to morestack.
 142 # Again the ARM and ppc64 work in less space.
 143 main 104 nosplit call f; f 0 call f
 144 main 108 nosplit call f; f 0 call f
 145 main 112 nosplit call f; f 0 call f; REJECT amd64
 146 main 116 nosplit call f; f 0 call f; REJECT amd64
 147 main 120 nosplit call f; f 0 call f; REJECT amd64 386
 148 main 124 nosplit call f; f 0 call f; REJECT amd64 386
 149 main 128 nosplit call f; f 0 call f; REJECT
 150 main 132 nosplit call f; f 0 call f; REJECT
 151 main 136 nosplit call f; f 0 call f; REJECT
 152
 153 # Indirect calls are assumed to be splitting functions.
 154 main 104 nosplit callind
 155 main 108 nosplit callind
 156 main 112 nosplit callind; REJECT amd64
 157 main 116 nosplit callind; REJECT amd64
 158 main 120 nosplit callind; REJECT amd64 386
 159 main 124 nosplit callind; REJECT amd64 386
 160 main 128 nosplit callind; REJECT
 161 main 132 nosplit callind; REJECT
 162 main 136 nosplit callind; REJECT
 163
 164 # Issue 7623
 165 main 0 call f; f 112
 166 main 0 call f; f 116
 167 main 0 call f; f 120
 168 main 0 call f; f 124
 169 main 0 call f; f 128
 170 main 0 call f; f 132
 171 main 0 call f; f 136
 172 `
 173
 174 var (
 175         commentRE = regexp.MustCompile(`(?m)^#.*`)
 176         rejectRE  = regexp.MustCompile(`(?s)\A(.+?)((\n|; *)REJECT(.*))?\z`)
 177         lineRE    = regexp.MustCompile(`(\w+) (\d+)( nosplit)?(.*)`)
 178         callRE    = regexp.MustCompile(`\bcall (\w+)\b`)
 179         callindRE = regexp.MustCompile(`\bcallind\b`)
 180 )
 181
 182 func main() {
 183         goarch := os.Getenv("GOARCH")
 184         if goarch == "" {
 185                 goarch = runtime.GOARCH
 186         }
 187
 188         thechar := ""
 189         if gochar, err := exec.Command("go", "env", "GOCHAR").Output(); err != nil {
 190                 bug()
 191                 fmt.Printf("running go env GOCHAR: %v\n", err)
 192                 return
 193         } else {
 194                 thechar = strings.TrimSpace(string(gochar))
 195         }
 196
 197         version, err := exec.Command("go", "tool", thechar+"g", "-V").Output()
 198         if err != nil {
 199                 bug()
 200                 fmt.Printf("running go tool %sg -V: %v\n", thechar, err)
 201                 return
 202         }
 203         if strings.Contains(string(version), "framepointer") {
 204                 // Skip this test if GOEXPERIMENT=framepointer
 205                 return
 206         }
 207
 208         dir, err := ioutil.TempDir("", "go-test-nosplit")
 209         if err != nil {
 210                 bug()
 211                 fmt.Printf("creating temp dir: %v\n", err)
 212                 return
 213         }
 214         defer os.RemoveAll(dir)
 215
 216         tests = strings.Replace(tests, "\t", " ", -1)
 217         tests = commentRE.ReplaceAllString(tests, "")
 218
 219         nok := 0
 220         nfail := 0
 221 TestCases:
 222         for len(tests) > 0 {
 223                 var stanza string
 224                 i := strings.Index(tests, "\nmain ")
 225                 if i < 0 {
 226                         stanza, tests = tests, ""
 227                 } else {
 228                         stanza, tests = tests[:i], tests[i+1:]
 229                 }
 230
 231                 m := rejectRE.FindStringSubmatch(stanza)
 232                 if m == nil {
 233                         bug()
 234                         fmt.Printf("invalid stanza:\n\t%s\n", indent(stanza))
 235                         continue
 236                 }
 237                 lines := strings.TrimSpace(m[1])
 238                 reject := false
 239                 if m[2] != "" {
 240                         if strings.TrimSpace(m[4]) == "" {
 241                                 reject = true
 242                         } else {
 243                                 for _, rej := range strings.Fields(m[4]) {
 244                                         if rej == goarch {
 245                                                 reject = true
 246                                         }
 247                                 }
 248                         }
 249                 }
 250                 if lines == "" && !reject {
 251                         continue
 252                 }
 253
 254                 var gobuf bytes.Buffer
 255                 fmt.Fprintf(&gobuf, "package main\n")
 256
 257                 var buf bytes.Buffer
 258                 ptrSize := 4
 259                 switch goarch {
 260                 case "ppc64", "ppc64le":
 261                         ptrSize = 8
 262                         fmt.Fprintf(&buf, "#define CALL BL\n#define REGISTER (CTR)\n#define RET RETURN\n")
 263                 case "arm":
 264                         fmt.Fprintf(&buf, "#define CALL BL\n#define REGISTER (R0)\n")
 265                 case "amd64":
 266                         ptrSize = 8
 267                         fmt.Fprintf(&buf, "#define REGISTER AX\n")
 268                 default:
 269                         fmt.Fprintf(&buf, "#define REGISTER AX\n")
 270                 }
 271
 272                 for _, line := range strings.Split(lines, "\n") {
 273                         line = strings.TrimSpace(line)
 274                         if line == "" {
 275                                 continue
 276                         }
 277                         for i, subline := range strings.Split(line, ";") {
 278                                 subline = strings.TrimSpace(subline)
 279                                 if subline == "" {
 280                                         continue
 281                                 }
 282                                 m := lineRE.FindStringSubmatch(subline)
 283                                 if m == nil {
 284                                         bug()
 285                                         fmt.Printf("invalid function line: %s\n", subline)
 286                                         continue TestCases
 287                                 }
 288                                 name := m[1]
 289                                 size, _ := strconv.Atoi(m[2])
 290
 291                                 // The limit was originally 128 but is now 512.
 292                                 // Instead of rewriting the test cases above, adjust
 293                                 // the first stack frame to use up the extra 32 bytes.
 294                                 if i == 0 {
 295                                         size += 512 - 128
 296                                 }
 297
 298                                 if size%ptrSize == 4 {
 299                                         continue TestCases
 300                                 }
 301                                 nosplit := m[3]
 302                                 body := m[4]
 303
 304                                 if nosplit != "" {
 305                                         nosplit = ",7"
 306                                 } else {
 307                                         nosplit = ",0"
 308                                 }
 309                                 body = callRE.ReplaceAllString(body, "CALL ·$1(SB);")
 310                                 body = callindRE.ReplaceAllString(body, "CALL REGISTER;")
 311
 312                                 fmt.Fprintf(&gobuf, "func %s()\n", name)
 313                                 fmt.Fprintf(&buf, "TEXT ·%s(SB)%s,$%d-0\n\t%s\n\tRET\n\n", name, nosplit, size, body)
 314                         }
 315                 }
 316
 317                 if err := ioutil.WriteFile(filepath.Join(dir, "asm.s"), buf.Bytes(), 0666); err != nil {
 318                         log.Fatal(err)
 319                 }
 320                 if err := ioutil.WriteFile(filepath.Join(dir, "main.go"), gobuf.Bytes(), 0666); err != nil {
 321                         log.Fatal(err)
 322                 }
 323
 324                 cmd := exec.Command("go", "build")
 325                 cmd.Dir = dir
 326                 output, err := cmd.CombinedOutput()
 327                 if err == nil {
 328                         nok++
 329                         if reject {
 330                                 bug()
 331                                 fmt.Printf("accepted incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza)))
 332                         }
 333                 } else {
 334                         nfail++
 335                         if !reject {
 336                                 bug()
 337                                 fmt.Printf("rejected incorrectly:\n\t%s\n", indent(strings.TrimSpace(stanza)))
 338                                 fmt.Printf("\n\tlinker output:\n\t%s\n", indent(string(output)))
 339                         }
 340                 }
 341         }
 342
 343         if !bugged && (nok == 0 || nfail == 0) {
 344                 bug()
 345                 fmt.Printf("not enough test cases run\n")
 346         }
 347 }
 348
 349 func indent(s string) string {
 350         return strings.Replace(s, "\n", "\n\t", -1)
 351 }
 352
 353 var bugged = false
 354
 355 func bug() {
 356         if !bugged {
 357                 bugged = true
 358                 fmt.Printf("BUG\n")
 359         }
 360 }