mirror of
https://github.com/golang/go
synced 2025-06-12 17:11:51 +00:00
Currently, the integer value in the following interface conversion gets heap allocated: v := 1000 fmt.Println(v) In contrast, this conversion does not currently cause the integer value to be heap allocated: fmt.Println(1000) The second example is able to avoid heap allocation because of an optimization in walk (by Josh in #18704 and related issues) that recognizes a literal is being used. In the first example, that optimization is currently thwarted by the literal getting assigned to a local variable prior to use in the interface conversion. This CL propagates constants to interface conversions like in the first example to avoid heap allocations, instead using a read-only global. The net effect is roughly turning the first example into the second. One place this comes up in practice currently is with logging or debug prints. For example, if we have something like: func conditionalDebugf(format string, args ...interface{}) { if debugEnabled { fmt.Fprintf(io.Discard, format, args...) } } Prior to this CL, this integer is heap allocated, even when the debugEnabled flag is false, and even when the compiler inlines conditionalDebugf: v := 1000 conditionalDebugf("hello %d", v) With this CL, the integer here is no longer heap allocated, even when the debugEnabled flag is enabled, because the compiler can now see that it can use a read-only global. See the writeup in #71359 for more details. CL 649076 (earlier in our stack) added most of the tests along with debug diagnostics in convert.go to make it easier to test this change. Updates #71359 Updates #62653 Updates #53465 Updates #8618 Change-Id: I19a51e74b36576ebb0b9cf599267cbd2bd847ce4 Reviewed-on: https://go-review.googlesource.com/c/go/+/649079 Auto-Submit: Keith Randall <khr@golang.org> Reviewed-by: Keith Randall <khr@golang.org> LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com> Reviewed-by: David Chase <drchase@google.com> Reviewed-by: Keith Randall <khr@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 "0 does not escape"
|
|
var y interface{} = j // ERROR "0 does not escape"
|
|
|
|
*(&v) = x.(int)
|
|
*(&v), *(&ok) = y.(int)
|
|
}
|
|
{ // #13805, #15796
|
|
i := 0
|
|
j := 0
|
|
var ok bool
|
|
var x interface{} = i // ERROR "0 does not escape"
|
|
var y interface{} = j // ERROR "0 does not escape"
|
|
|
|
sink = x.(int) // ERROR "x.\(int\) escapes to heap"
|
|
sink, *(&ok) = y.(int) // ERROR "autotmp_.* escapes to heap"
|
|
}
|
|
{
|
|
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"
|
|
}
|