go/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
}

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
}

func foo13(yyy **int) {
	*xxx = *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
}

func foo17(yy *int) {
	**xxx = *yy
}

func foo18(y int) {  // ERROR "moved to heap: "NAME-y"
	*xxx = &y
}

func foo19(y int) {
	**xxx = y
}

type Bar struct {
	i int
	ii *int
}

func NewBar() *Bar {
	return &Bar{ 42, nil }
}

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)
}

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 {
	x := 42
	return func() int {
		return x
	}()
}

func foo23(x int) func() int {  // ERROR "moved to heap: NAME-x"
	return func() int {
		return x
	}
}

func foo23a(x int) (func() int) {  // ERROR "moved to heap: NAME-x"
	f := func() int {
		return x
	}
	return f
}

func foo23b(x int) *(func() int) {  // ERROR "moved to heap: NAME-x"
	f := func() int { return x } // ERROR "moved to heap: NAME-f"
	return &f
}

func foo24(x int) int {
	return func() int {
		return x
	}()
}


var x *int

func fooleak(xx *int) int {    // ERROR "leaking param: NAME-xx"
	x = xx
	return *x
}

func foonoleak(xx *int) int {
	return *x + *xx
}

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 
}

func (f *Foo) foo46() {
	F.xx = f.xx 
}

func (f *Foo) foo47() {  // ERROR "leaking param: NAME-f"
	f.xx = &f.x
}


var ptrSlice []*int

func foo50(i *int) {  // ERROR "leaking param: NAME-i"
	ptrSlice[0] = i
}


var ptrMap map[*int]*int

func foo51(i *int) {   // ERROR "leaking param: NAME-i"
	ptrMap[i] = i
}


func indaddr1(x int) *int { // ERROR "moved to heap: NAME-x"
	return &x
}

func indaddr2(x *int) *int {   // ERROR "leaking param: NAME-x"
	return *&x
}

func indaddr3(x *int32) *int {    // ERROR "leaking param: NAME-x"
	return *(**int)(unsafe.Pointer(&x))
}

// From package math:

func Float32bits(f float32) uint32 {
	return *(*uint32)(unsafe.Pointer(&f))
}

func Float32frombits(b uint32) float32 {
	return *(*float32)(unsafe.Pointer(&b))
}

func Float64bits(f float64) uint64 {
	return *(*uint64)(unsafe.Pointer(&f))
}

func Float64frombits(b uint64) float64 {
	return *(*float64)(unsafe.Pointer(&b))
}

// contrast with
func float64bitsptr(f float64) *uint64 {  // ERROR "moved to heap: NAME-f"
	return (*uint64)(unsafe.Pointer(&f))
}

func float64ptrbitsptr(f *float64) *uint64 {  // ERROR "leaking param: NAME-f"
	return (*uint64)(unsafe.Pointer(f))
}

func typesw(i interface{}) *int {  // ERROR "leaking param: NAME-i"
	switch val := i.(type) {
	case *int:
		return val
	case *int8:
		v := int(*val)  // ERROR "moved to heap: NAME-v"
		return &v
	}
	return nil
}

func exprsw(i *int) *int {	// ERROR "leaking param: NAME-i"
	switch j := i; *j + 110 {
	case 12:
		return j
	case 42:
		return nil
	}
	return nil

}

// assigning to an array element is like assigning to the array
func foo60(i *int) *int {  // ERROR "leaking param: NAME-i"
	var a [12]*int
	a[0] = i
	return a[1]
}

func foo60a(i *int) *int {
	var a [12]*int
	a[0] = i
	return nil
}

// assigning to a struct field  is like assigning to the struct
func foo61(i *int) *int {   // ERROR "leaking param: NAME-i"
	type S struct {
		a,b *int
	}
	var s S
	s.a = i
	return s.b
}

func foo61a(i *int) *int {
	type S struct {
		a,b *int
	}
	var s S
	s.a = i
	return nil
}

// assigning to a struct field is like assigning to the struct but
// here this subtlety is lost, since s.a counts as an assignment to a
// 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 }
}