...
Run Format

Source file test/fixedbugs/issue13799.go

Documentation: test/fixedbugs

     1  // errorcheck -0 -m -l
     2  
     3  // Copyright 2015 The Go Authors. All rights reserved.
     4  // Use of this source code is governed by a BSD-style
     5  // license that can be found in the LICENSE file.
     6  
     7  // Test, using compiler diagnostic flags, that the escape analysis is working.
     8  // Compiles but does not run.  Inlining is disabled.
     9  // Registerization is disabled too (-N), which should
    10  // have no effect on escape analysis.
    11  
    12  package main
    13  
    14  import "fmt"
    15  
    16  func main() {
    17  	// Just run test over and over again. This main func is just for
    18  	// convenience; if test were the main func, we could also trigger
    19  	// the panic just by running the program over and over again
    20  	// (sometimes it takes 1 time, sometimes it takes ~4,000+).
    21  	for iter := 0; ; iter++ {
    22  		if iter%50 == 0 {
    23  			fmt.Println(iter) // ERROR "iter escapes to heap$" "main ... argument does not escape$"
    24  		}
    25  		test1(iter)
    26  		test2(iter)
    27  		test3(iter)
    28  		test4(iter)
    29  		test5(iter)
    30  		test6(iter)
    31  	}
    32  }
    33  
    34  func test1(iter int) {
    35  
    36  	const maxI = 500
    37  	m := make(map[int][]int) // ERROR "make\(map\[int\]\[\]int\) escapes to heap$"
    38  
    39  	// The panic seems to be triggered when m is modified inside a
    40  	// closure that is both recursively called and reassigned to in a
    41  	// loop.
    42  
    43  	// Cause of bug -- escape of closure failed to escape (shared) data structures
    44  	// of map.  Assign to fn declared outside of loop triggers escape of closure.
    45  	// Heap -> stack pointer eventually causes badness when stack reallocation
    46  	// occurs.
    47  
    48  	var fn func()               // ERROR "moved to heap: fn$"
    49  	for i := 0; i < maxI; i++ { // ERROR "moved to heap: i$"
    50  		// var fn func() // this makes it work, because fn stays off heap
    51  		j := 0        // ERROR "moved to heap: j$"
    52  		fn = func() { // ERROR "func literal escapes to heap$"
    53  			m[i] = append(m[i], 0) // ERROR "&i escapes to heap$"
    54  			if j < 25 {            // ERROR "&j escapes to heap$"
    55  				j++
    56  				fn() // ERROR "&fn escapes to heap$"
    57  			}
    58  		}
    59  		fn()
    60  	}
    61  
    62  	if len(m) != maxI {
    63  		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "test1 ... argument does not escape$"
    64  	}
    65  }
    66  
    67  func test2(iter int) {
    68  
    69  	const maxI = 500
    70  	m := make(map[int][]int) // ERROR "test2 make\(map\[int\]\[\]int\) does not escape$"
    71  
    72  	// var fn func()
    73  	for i := 0; i < maxI; i++ {
    74  		var fn func() // this makes it work, because fn stays off heap
    75  		j := 0
    76  		fn = func() { // ERROR "test2 func literal does not escape$"
    77  			m[i] = append(m[i], 0)
    78  			if j < 25 {
    79  				j++
    80  				fn()
    81  			}
    82  		}
    83  		fn()
    84  	}
    85  
    86  	if len(m) != maxI {
    87  		panic(fmt.Sprintf("iter %d: maxI = %d, len(m) = %d", iter, maxI, len(m))) // ERROR "iter escapes to heap$" "len\(m\) escapes to heap$" "maxI escapes to heap$" "test2 ... argument does not escape$"
    88  	}
    89  }
    90  
    91  func test3(iter int) {
    92  
    93  	const maxI = 500
    94  	var x int // ERROR "moved to heap: x$"
    95  	m := &x   // ERROR "&x escapes to heap$"
    96  
    97  	var fn func() // ERROR "moved to heap: fn$"
    98  	for i := 0; i < maxI; i++ {
    99  		// var fn func() // this makes it work, because fn stays off heap
   100  		j := 0        // ERROR "moved to heap: j$"
   101  		fn = func() { // ERROR "func literal escapes to heap$"
   102  			if j < 100 { // ERROR "&j escapes to heap$"
   103  				j++
   104  				fn() // ERROR "&fn escapes to heap$"
   105  			} else {
   106  				*m = *m + 1
   107  			}
   108  		}
   109  		fn()
   110  	}
   111  
   112  	if *m != maxI {
   113  		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test3 ... argument does not escape$"
   114  	}
   115  }
   116  
   117  func test4(iter int) {
   118  
   119  	const maxI = 500
   120  	var x int
   121  	m := &x // ERROR "test4 &x does not escape$"
   122  
   123  	// var fn func()
   124  	for i := 0; i < maxI; i++ {
   125  		var fn func() // this makes it work, because fn stays off heap
   126  		j := 0
   127  		fn = func() { // ERROR "test4 func literal does not escape$"
   128  			if j < 100 {
   129  				j++
   130  				fn()
   131  			} else {
   132  				*m = *m + 1
   133  			}
   134  		}
   135  		fn()
   136  	}
   137  
   138  	if *m != maxI {
   139  		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test4 ... argument does not escape$"
   140  	}
   141  }
   142  
   143  type str struct {
   144  	m *int
   145  }
   146  
   147  func recur1(j int, s *str) { // ERROR "recur1 s does not escape"
   148  	if j < 100 {
   149  		j++
   150  		recur1(j, s)
   151  	} else {
   152  		*s.m++
   153  	}
   154  }
   155  
   156  func test5(iter int) {
   157  
   158  	const maxI = 500
   159  	var x int // ERROR "moved to heap: x$"
   160  	m := &x   // ERROR "&x escapes to heap$"
   161  
   162  	var fn *str
   163  	for i := 0; i < maxI; i++ {
   164  		// var fn *str // this makes it work, because fn stays off heap
   165  		fn = &str{m} // ERROR "&str literal escapes to heap"
   166  		recur1(0, fn)
   167  	}
   168  
   169  	if *m != maxI {
   170  		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test5 ... argument does not escape$"
   171  	}
   172  }
   173  
   174  func test6(iter int) {
   175  
   176  	const maxI = 500
   177  	var x int
   178  	m := &x // ERROR "&x does not escape$"
   179  
   180  	// var fn *str
   181  	for i := 0; i < maxI; i++ {
   182  		var fn *str  // this makes it work, because fn stays off heap
   183  		fn = &str{m} // ERROR "&str literal does not escape"
   184  		recur1(0, fn)
   185  	}
   186  
   187  	if *m != maxI {
   188  		panic(fmt.Sprintf("iter %d: maxI = %d, *m = %d", iter, maxI, *m)) // ERROR "\*m escapes to heap$" "iter escapes to heap$" "maxI escapes to heap$" "test6 ... argument does not escape$"
   189  	}
   190  }
   191  

View as plain text