qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-24 10:40:10 -07:00
Code Releases Activity

Revert "cmd/compile: stop interface conversions for generic method calls from allocating"

Browse Source 
This reverts commit e550c30545.

Reason for revert: Method bound calls are no longer implemented using interface calls, so it is no longer necessary. Leaving the test, though.

Change-Id: I80f1e4cd921063cd27ca8f07998316ca282e075b
Reviewed-on: https://go-review.googlesource.com/c/go/+/395594
Trust: Keith Randall <khr@golang.org>
Run-TryBot: Keith Randall <khr@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
This commit is contained in:
Keith Randall 2022-03-24 17:50:06 +00:00
parent f326964824
commit 3f69cc7d77
3 changed files with 4 additions and 20 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
src/cmd/compile/internal/escape/escape.go
View File

@ -297,14 +297,6 @@ func (b *batch) finish(fns []*ir.Func) {
// TODO(mdempsky): Update tests to expect this.
goDeferWrapper := n.Op() == ir.OCLOSURE && n.(*ir.ClosureExpr).Func.Wrapper()
if n.Op() == ir.OCONVIDATA && n.(*ir.ConvExpr).NonEscaping {
// The allocation for the data word of an interface is known to not escape.
// See issue 50182.
// (But we do still need to process that allocation, as pointers inside
// the data word may escape.)
loc.escapes = false
}
if loc.escapes {
if n.Op() == ir.ONAME {
if base.Flag.CompilingRuntime {

3
src/cmd/compile/internal/ir/expr.go
View File

@ -244,8 +244,7 @@ func (n *ConstExpr) Val() constant.Value { return n.val }
// It may end up being a value or a type.
type ConvExpr struct {
miniExpr
X Node
NonEscaping bool // The allocation needed for the conversion to interface is known not to escape
X Node
}
func NewConvExpr(pos src.XPos, op Op, typ *types.Type, x Node) *ConvExpr {

13
src/cmd/compile/internal/noder/stencil.go
View File

@ -1279,11 +1279,7 @@ func (g *genInst) dictPass(info *instInfo) {
// we do a type assert to the type bound.
mse.X = assertToBound(info, info.dictParam, m.Pos(), mse.X, dst)
} else {
mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst, true)
// Note: we set nonEscaping==true, because we can assume the backing store for the
// interface conversion doesn't escape. The method call will immediately go to
// a wrapper function which copies all the data out of the interface value.
// (It only matters for non-pointer-shaped interface conversions. See issue 50182.)
mse.X = convertUsingDictionary(info, info.dictParam, m.Pos(), mse.X, m, dst)
}
}
transformDot(mse, false)
@ -1329,7 +1325,7 @@ func (g *genInst) dictPass(info *instInfo) {
// Note: x's argument is still typed as a type parameter.
// m's argument now has an instantiated type.
if mce.X.Type().HasShape() || (mce.X.Type().IsInterface() && m.Type().HasShape()) {
m = convertUsingDictionary(info, info.dictParam, m.Pos(), m.(*ir.ConvExpr).X, m, m.Type(), false)
m = convertUsingDictionary(info, info.dictParam, m.Pos(), m.(*ir.ConvExpr).X, m, m.Type())
}
case ir.ODOTTYPE, ir.ODOTTYPE2:
if !m.Type().HasShape() {
@ -1422,9 +1418,7 @@ func findDictType(info *instInfo, t *types.Type) int {
// type dst, by returning a new set of nodes that make use of a dictionary entry. in is the
// instantiated node of the CONVIFACE node or XDOT node (for a bound method call) that is causing the
// conversion.
// If nonEscaping is true, the caller guarantees that the backing store needed for the interface data
// word will not escape.
func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v ir.Node, in ir.Node, dst *types.Type, nonEscaping bool) ir.Node {
func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v ir.Node, in ir.Node, dst *types.Type) ir.Node {
assert(v.Type().HasShape() || v.Type().IsInterface() && in.Type().HasShape())
assert(dst.IsInterface())
@ -1494,7 +1488,6 @@ func convertUsingDictionary(info *instInfo, dictParam *ir.Name, pos src.XPos, v
// Figure out what the data field of the interface will be.
data := ir.NewConvExpr(pos, ir.OCONVIDATA, nil, v)
typed(types.Types[types.TUNSAFEPTR], data)
data.NonEscaping = nonEscaping
// Build an interface from the type and data parts.
var i ir.Node = ir.NewBinaryExpr(pos, ir.OEFACE, rt, data)