1
0
mirror of https://github.com/golang/go synced 2024-11-27 01:41:23 -07:00
go/test/escape_iface.go
Matthew Dempsky e62adb1c0b cmd/compile: fix devirtualization of promoted interface methods
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>
2020-10-30 00:47:37 +00:00

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