mirror of
https://github.com/golang/go
synced 2024-09-06 00:19:45 +00:00
![Matthew Dempsky](/assets/img/avatar_default.png)
A method selector expression can pick out a method or promoted method (represented by ODOTMETH), but it can also pick out an interface method from an embedded interface-typed field (represented by ODOTINTER). In the case that we're picking out an interface method, we're not able to fully devirtualize the method call. However, we're still able to improve escape analysis somewhat. E.g., the included test case demonstrates that we can optimize "i.M()" to "i.(T).I.M()", which means the T literal can be stack allocated instead of heap allocated. Fixes #42279. Change-Id: Ifa21d19011e2f008d84f9624b7055b4676b6d188 Reviewed-on: https://go-review.googlesource.com/c/go/+/266300 Trust: Matthew Dempsky <mdempsky@google.com> Run-TryBot: Matthew Dempsky <mdempsky@google.com> TryBot-Result: Go Bot <gobot@golang.org> Reviewed-by: David Chase <drchase@google.com>
266 lines
4.5 KiB
Go
266 lines
4.5 KiB
Go
// errorcheck -0 -m -l
|
|
|
|
// Copyright 2015 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.
|
|
|
|
// Test escape analysis for interface conversions.
|
|
|
|
package escape
|
|
|
|
var sink interface{}
|
|
|
|
type M interface {
|
|
M()
|
|
}
|
|
|
|
func mescapes(m M) { // ERROR "leaking param: m"
|
|
sink = m
|
|
}
|
|
|
|
func mdoesnotescape(m M) { // ERROR "m does not escape"
|
|
}
|
|
|
|
// Tests for type stored directly in iface and with value receiver method.
|
|
type M0 struct {
|
|
p *int
|
|
}
|
|
|
|
func (M0) M() {
|
|
}
|
|
|
|
func efaceEscape0() {
|
|
{
|
|
i := 0
|
|
v := M0{&i}
|
|
var x M = v
|
|
_ = x
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M0{&i}
|
|
var x M = v
|
|
sink = x
|
|
}
|
|
{
|
|
i := 0
|
|
v := M0{&i}
|
|
var x M = v
|
|
v1 := x.(M0)
|
|
_ = v1
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M0{&i}
|
|
// BAD: v does not escape to heap here
|
|
var x M = v
|
|
v1 := x.(M0)
|
|
sink = v1
|
|
}
|
|
{
|
|
i := 0
|
|
v := M0{&i}
|
|
var x M = v
|
|
x.M() // ERROR "devirtualizing x.M"
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M0{&i}
|
|
var x M = v
|
|
mescapes(x)
|
|
}
|
|
{
|
|
i := 0
|
|
v := M0{&i}
|
|
var x M = v
|
|
mdoesnotescape(x)
|
|
}
|
|
}
|
|
|
|
// Tests for type stored indirectly in iface and with value receiver method.
|
|
type M1 struct {
|
|
p *int
|
|
x int
|
|
}
|
|
|
|
func (M1) M() {
|
|
}
|
|
|
|
func efaceEscape1() {
|
|
{
|
|
i := 0
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v does not escape"
|
|
_ = x
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v escapes to heap"
|
|
sink = x
|
|
}
|
|
{
|
|
i := 0
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v does not escape"
|
|
v1 := x.(M1)
|
|
_ = v1
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v does not escape"
|
|
v1 := x.(M1)
|
|
sink = v1 // ERROR "v1 escapes to heap"
|
|
}
|
|
{
|
|
i := 0
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v does not escape"
|
|
x.M() // ERROR "devirtualizing x.M"
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v escapes to heap"
|
|
mescapes(x)
|
|
}
|
|
{
|
|
i := 0
|
|
v := M1{&i, 0}
|
|
var x M = v // ERROR "v does not escape"
|
|
mdoesnotescape(x)
|
|
}
|
|
}
|
|
|
|
// Tests for type stored directly in iface and with pointer receiver method.
|
|
type M2 struct {
|
|
p *int
|
|
}
|
|
|
|
func (*M2) M() {
|
|
}
|
|
|
|
func efaceEscape2() {
|
|
{
|
|
i := 0
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
var x M = v
|
|
_ = x
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := &M2{&i} // ERROR "&M2{...} escapes to heap"
|
|
var x M = v
|
|
sink = x
|
|
}
|
|
{
|
|
i := 0
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
var x M = v
|
|
v1 := x.(*M2)
|
|
_ = v1
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := &M2{&i} // ERROR "&M2{...} escapes to heap"
|
|
// BAD: v does not escape to heap here
|
|
var x M = v
|
|
v1 := x.(*M2)
|
|
sink = v1
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
// BAD: v does not escape to heap here
|
|
var x M = v
|
|
v1 := x.(*M2)
|
|
sink = *v1
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
// BAD: v does not escape to heap here
|
|
var x M = v
|
|
v1, ok := x.(*M2)
|
|
sink = *v1
|
|
_ = ok
|
|
}
|
|
{
|
|
i := 0
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
var x M = v
|
|
x.M() // ERROR "devirtualizing x.M"
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
v := &M2{&i} // ERROR "&M2{...} escapes to heap"
|
|
var x M = v
|
|
mescapes(x)
|
|
}
|
|
{
|
|
i := 0
|
|
v := &M2{&i} // ERROR "&M2{...} does not escape"
|
|
var x M = v
|
|
mdoesnotescape(x)
|
|
}
|
|
}
|
|
|
|
type T1 struct {
|
|
p *int
|
|
}
|
|
|
|
type T2 struct {
|
|
T1 T1
|
|
}
|
|
|
|
func dotTypeEscape() *T2 { // #11931
|
|
var x interface{}
|
|
x = &T1{p: new(int)} // ERROR "new\(int\) escapes to heap" "&T1{...} does not escape"
|
|
return &T2{ // ERROR "&T2{...} escapes to heap"
|
|
T1: *(x.(*T1)),
|
|
}
|
|
}
|
|
|
|
func dotTypeEscape2() { // #13805, #15796
|
|
{
|
|
i := 0
|
|
j := 0
|
|
var v int
|
|
var ok bool
|
|
var x interface{} = i // ERROR "i does not escape"
|
|
var y interface{} = j // ERROR "j does not escape"
|
|
|
|
*(&v) = x.(int)
|
|
*(&v), *(&ok) = y.(int)
|
|
}
|
|
{
|
|
i := 0
|
|
j := 0
|
|
var ok bool
|
|
var x interface{} = i // ERROR "i does not escape"
|
|
var y interface{} = j // ERROR "j does not escape"
|
|
|
|
sink = x.(int) // ERROR "x.\(int\) escapes to heap"
|
|
sink, *(&ok) = y.(int)
|
|
}
|
|
{
|
|
i := 0 // ERROR "moved to heap: i"
|
|
j := 0 // ERROR "moved to heap: j"
|
|
var ok bool
|
|
var x interface{} = &i
|
|
var y interface{} = &j
|
|
|
|
sink = x.(*int)
|
|
sink, *(&ok) = y.(*int)
|
|
}
|
|
}
|
|
|
|
func issue42279() {
|
|
type I interface{ M() }
|
|
type T struct{ I }
|
|
|
|
var i I = T{} // ERROR "T\{\} does not escape"
|
|
i.M() // ERROR "partially devirtualizing i.M to T"
|
|
}
|