code review 4634073: gc: Escape analysis.

test/escape2.go

 // errchk -0 $G -sm $D/$F.go
 
 // 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 foo
 
 import "unsafe"
 
 var gxx *int
 
 func foo1(x int) {  // ERROR "moved to heap: NAME-x"
         gxx = &x
 }
 
 func foo2(yy *int) {  // ERROR "leaking param: NAME-yy"
         gxx = yy
 }
 
 func foo3(x int) *int {  // ERROR "moved to heap: NAME-x"
         return &x
 }
 
+type T *T
+func foo3b(t T) {  // ERROR "leaking param: NAME-t"
+        *t = t
+}
+
 // xx isn't going anywhere, so use of yy is ok
 func foo4(xx, yy *int) {
         xx = yy
 }
 
 // xx isn't going anywhere, so taking address of yy is ok
 func foo5(xx **int, yy *int) {
         xx = &yy
 }
 
 func foo6(xx **int, yy *int) {  // ERROR "leaking param: NAME-yy"
         *xx = yy
 }
 
 func foo7(xx **int, yy *int) {
         **xx = *yy
 }
 
 func foo8(xx, yy *int) int {
         xx = yy
         return *xx
 }
 
-// also xx, but chkmsg takes only 1
-func foo9(xx, yy *int) *int {  // ERROR "leaking param: NAME-yy"
+func foo9(xx, yy *int) *int {  // ERROR "leaking param: NAME-xx" "leaking param: NAME-yy"
         xx = yy
         return xx
 }
 
 func foo10(xx, yy *int) {
         *xx = *yy
 }
 
 func foo11() int {
         x, y := 0, 42
         xx := &x
         yy := &y
         *xx = *yy
         return x
 }
 
 
 var xxx **int
 
 func foo12(yyy **int) {   // ERROR "leaking param: NAME-yyy"
         xxx = yyy
 }
 
-// spurious
-func foo13(yyy **int) {   // ERROR "leaking param: NAME-yyy"
+func foo13(yyy **int) {
         *xxx = *yyy
 }
 
-// spurious
-func foo14(yyy **int) {    // ERROR "leaking param: NAME-yyy"
+func foo14(yyy **int) {
         **xxx = **yyy
 }
 
 func foo15(yy *int) {  // ERROR "moved to heap: NAME-yy"
         xxx = &yy
 }
 
 func foo16(yy *int) {  // ERROR "leaking param: NAME-yy"
         *xxx = yy
 }
@@ skipping 12 matching lines @@
 
 type Bar struct {
         i int
         ii *int
 }
 
 func NewBar() *Bar {
         return &Bar{ 42, nil }
 }
 
-// spurious
-func (b *Bar) NoLeak() int {   // ERROR "leaking param: NAME-b"
+func NewBarp(x *int) *Bar {  // ERROR "leaking param: NAME-x"
+        return &Bar{ 42, x }
+}
+
+func NewBarp2(x *int) *Bar {
+        return &Bar{ *x, nil }
+}
+
+func (b *Bar) NoLeak() int {
         return *(b.ii)
 }
 
-// spurious
-func (b *Bar) AlsoNoLeak() *int {  // ERROR "leaking param: NAME-b"
+func (b *Bar) AlsoNoLeak() *int {
         return b.ii
 }
 
 type Bar2 struct {
         i [12]int
         ii []int
 }
 
 func NewBar2() *Bar2 {
         return &Bar2{ [12]int{ 42 },  nil }
 }
 
 func (b *Bar2) NoLeak() int {
         return b.i[0]
 }
 
 func (b *Bar2) Leak() []int {  // ERROR "leaking param: NAME-b"
+        return b.i[:]
+}
+
+func (b *Bar2) AlsoNoLeak() []int {
         return b.ii[0:1]
+}
+
+func (b *Bar2) LeakSelf() {  // ERROR "leaking param: NAME-b"
+        b.ii = b.i[0:4]
+}
+
+func (b *Bar2) LeakSelf2() {  // ERROR "leaking param: NAME-b"
+        var buf []int
+        buf = b.i[0:]
+        b.ii = buf
 }
 
 func foo21() func() int {
         x := 42  // ERROR "moved to heap: NAME-x"
         return func() int {
                 return x
         }
 }
 
 func foo22() int {
@@ skipping 40 matching lines @@
 }
 
 func foo31(x int) int {  // ERROR "moved to heap: NAME-x"
         return fooleak(&x)
 }
 
 func foo32(x int) int {
         return foonoleak(&x)
 }
 
-
 type Foo struct {
         xx *int
         x int
 }
 
 var F Foo
+var pf *Foo
+
+func (f *Foo) fooleak() {  // ERROR "leaking param: NAME-f"
+        pf = f
+}
+
+func (f *Foo) foonoleak() {
+        F.x = f.x
+}
+
+func (f *Foo) Leak() {  // ERROR "leaking param: NAME-f"
+        f.fooleak()
+}
+
+func (f *Foo) NoLeak() {
+        f.foonoleak()
+}
+
 
 func foo41(x int) {  // ERROR "moved to heap: NAME-x"
         F.xx = &x
 }
 
 func (f *Foo) foo42(x int) {   // ERROR "moved to heap: NAME-x"
         f.xx = &x
 }
 
 func foo43(f *Foo, x int) {   // ERROR "moved to heap: NAME-x"
         f.xx = &x
 }
 
 func foo44(yy *int) {  // ERROR "leaking param: NAME-yy"
         F.xx = yy
 }
 
 func (f *Foo) foo45() {
         F.x = f.x·
 }
 
-// spurious
-func (f *Foo) foo46() {  // ERROR "leaking param: NAME-f"
+func (f *Foo) foo46() {
         F.xx = f.xx·
 }
 
 func (f *Foo) foo47() {  // ERROR "leaking param: NAME-f"
         f.xx = &f.x
 }
 
 
 var ptrSlice []*int
 
@@ skipping 107 matching lines @@
 // track-losing dereference.
 func foo62(i *int) *int {   // ERROR "leaking param: NAME-i"
         type S struct {
                 a,b *int
         }
         s := new(S)
         s.a = i
         return nil  // s.b
 }
 
+
+type M interface { M() }
+
+func foo63(m M) {
+}
+
+func foo64(m M) {  // ERROR "leaking param: NAME-m"
+        m.M()
+}
+
+type MV int
+func (MV) M() {}
+
+func foo65() {
+        var mv MV
+        foo63(&mv)
+}
+
+func foo66() {
+        var mv MV  // ERROR "moved to heap: NAME-mv"
+        foo64(&mv)
+}
+
+func foo67() {
+        var mv MV
+        foo63(mv)
+}
+
+func foo68() {
+        var mv MV
+        foo64(mv)  // escapes but it's an int so irrelevant
+}
+
+func foo69(m M) {  // ERROR "leaking param: NAME-m"
+        foo64(m)
+}
+
+func foo70(mv1 *MV, m M) {  // ERROR "leaking param: NAME-mv1" "leaking param: NAME-m"
+        m = mv1
+        foo64(m)
+}
+
+func foo71(x *int) []*int {  // ERROR "leaking param: NAME-x"
+        var y []*int
+        y = append(y, x)
+        return y
+}
+
+func foo71a(x int) []*int {  // ERROR "moved to heap: NAME-x"
+        var y []*int
+        y = append(y, &x)
+        return y
+}
+
+func foo72() {
+        var x int
+        var y [1]*int
+        y[0] = &x
+}
+
+func foo72aa() [10]*int {
+        var x int  // ERROR "moved to heap: NAME-x"
+        var y [10]*int
+        y[0] = &x
+        return y
+}
+
+func foo72a() {
+        var y [10]*int
+        for i := 0; i < 10; i++ {
+                x := i  // not moved to heap b/c y goes nowhere
+                y[i] = &x
+        }
+        return
+}
+
+func foo72b() [10]*int {
+        var y [10]*int
+        for i := 0; i < 10; i++ {
+                x := i  // ERROR "moved to heap: NAME-x"
+                y[i] = &x
+        }
+        return y
+}
+
+
+// issue 2145
+func foo73() {
+        s := []int{3,2,1}
+        for _, v := range s {
+                vv := v  // ERROR "moved to heap: NAME-vv"
+                defer func() {  //  "func literal escapes its scope" "&vv escapes its scope"
+                        println(vv)
+                }()
+        }
+}
+
+func foo74() {
+        s := []int{3,2,1}
+        for _, v := range s {
+                vv := v  // ERROR "moved to heap: NAME-vv"
+                fn := func() {  //  "func literal escapes its scope" "&vv escapes its scope"
+                        println(vv)
+                }
+                defer fn()
+        }
+}
+
+func myprint(y *int, x ...interface{}) *int {  // ERROR "leaking param: NAME-y"
+        return y
+}
+
+func myprint1(y *int, x ...interface{}) *interface{} {  // ERROR "leaking param: NAME-x"
+        return &x[0]
+}
+
+func foo75(z *int) { // ERROR "leaking param: NAME-z"
+        myprint(z, 1, 2, 3)
+}
+
+func foo75a(z *int) {
+        myprint1(z, 1, 2, 3)  // "[.][.][.] argument escapes to heap"
+}
+
+func foo76(z *int) {
+        myprint(nil, z)
+}
+
+func foo76a(z *int) {  // ERROR "leaking param: NAME-z"
+        myprint1(nil, z)  // "[.][.][.] argument escapes to heap"
+}
+
+func foo76b() {
+        myprint(nil, 1, 2, 3)
+}
+
+func foo76c() {
+        myprint1(nil, 1, 2, 3) // "[.][.][.] argument escapes to heap"
+}
+
+func foo76d() {
+        defer myprint(nil, 1, 2, 3)
+}
+
+func foo76e() {
+        defer myprint1(nil, 1, 2, 3) // "[.][.][.] argument escapes to heap"
+}
+
+func foo76f() {
+        for {
+                defer myprint(nil, 1, 2, 3) // "[.][.][.] argument escapes its scope"
+        }
+}
+
+func foo76g() {
+        for {
+                defer myprint1(nil, 1, 2, 3) // "[.][.][.] argument escapes to heap"
+        }
+}
+
+func foo77(z []interface{}) {
+        myprint(nil, z...)  // z does not escape
+}
+
+func foo77a(z []interface{}) {  // ERROR "leaking param: NAME-z"
+        myprint1(nil, z...)
+}
+
+func foo78(z int) *int {  // ERROR "moved to heap: NAME-z"
+        return &z  //  "&z escapes"
+}
+
+func foo78a(z int) *int {  // ERROR "moved to heap: NAME-z"
+        y := &z
+        x := &y
+        return *x  // really return y
+}
+
+func foo79() *int {
+        return new(int)  //  "moved to heap: new[(]int[)]"
+}
+
+func foo80() *int {
+        var z *int
+        for {
+                z = new(int) //  "new[(]int[)] escapes its scope"
+        }
+        _ = z
+        return nil
+}
+
+func foo81() *int {
+        for {
+                z := new(int)
+                _ = z
+        }
+        return nil
+}
+
+type Fooer interface {
+        Foo()
+}
+
+type LimitedFooer struct {
+        Fooer
+        N int64
+}
+
+func LimitFooer(r Fooer, n int64) Fooer {  // ERROR "leaking param: NAME-r"
+        return &LimitedFooer{r, n}
+}
+
+func foo90(x *int) map[*int]*int {  // ERROR "leaking param: NAME-x"
+        return map[*int]*int{ nil: x }
+}
+
+func foo91(x *int) map[*int]*int {  // ERROR "leaking param: NAME-x"
+        return map[*int]*int{ x:nil }
+}
+
+func foo92(x *int) [2]*int {  // ERROR "leaking param: NAME-x"
+        return [2]*int{ x, nil }
+}
+