cmd/compile: inaccurate escape to heap message

[zigo101]

What version of Go are you using (go version)?

$ go version
go version go1.16 linux/amd64

Does this issue reproduce with the latest release?

Yes.

What did you do?

package main

var i interface{}

func f() {
  type T int
  var a [1<<20]byte
  i = a // a escapes to heap
}

func main(){
  var x int
  println(&x)
  f()
  println(&x)
}

What did you expect to see?

$ go build -gcflags="-m" a.go
# command-line-arguments
./a.go:11:6: can inline main
./a.go:8:5: a copy of a escapes to heap

What did you see instead?

$ go build -gcflags="-m" a.go
# command-line-arguments
./a.go:11:6: can inline main
./a.go:8:5: a escapes to heap

[cuiweixie]

what should we expect to see a copy of a escapes to heap

[zigo101]

From logic, a should not escape to heap. And this gets verified by the fact that the compiler doesn't report escape for line 7.

Maybe nothing needs to change here. The message a escapes to heap for line 8 should be interpreted as a, as a right value, escapes to heap. But a little more accuracy would be better.

[zigo101]

It looks escape analysis misses a escapes to heap message for make(chan bool)

package main

func main() {
	x := new(int)          // new(int) escapes to heap
	c := make(chan bool)   // (missing)
	s := make([]int, 5)    // make([]int, 5) escapes to heap
	m := make(map[int]int) // make(map[int]int) escapes to heap
	go func() {
		*x = 1
		s[0] = 1
		m[1] = 1
		close(c)
	}()
	<-c
	println(*x)
	println(x)
	println(s[0])
	println(m[1])
}

[randall77]

Channels can't be allocated on the stack, so I don't think there's value in tracking their escapiness.

[zigo101]

Reasonable, mainly for sorting purpose in select blocks?

Will a channel used as a FIFO queue in a single goroutine be allocated on heap?

[randall77]

Reasonable, mainly for sorting purpose in select blocks?

That would be one complication of stack allocation, yes.

Will a channel used as a FIFO queue in a single goroutine be allocated on heap?

Yes, currently.

[zigo101]

And this? It looks [N]byte{} doesn't escape.

package main

const N = 100 * 1024 * 1024

var i interface{}
func bar() {
	i = [N]byte{} // [104857600]byte{} escapes to heap
}


func main() {
	run := func(f func(), c chan struct{}) {
		defer close(c)
		var x int
		println(&x) // <address 1>
		f()
		println(&x) // <address 2>
	}

	c2 := make(chan struct{})
	go run(bar, c2)
	<-c2
}

[randall77]

It is stack allocating a big byte array. Not sure why that escape message is there - maybe it refers to the copy that is the backing store for the interface?