From 72b6a89ca5cd3c3bfd13b9b17be976e8feb91ecc Mon Sep 17 00:00:00 2001 From: Keith Randall Date: Thu, 21 Oct 2021 18:09:07 -0700 Subject: [PATCH] cmd/compile: revert most of CL 349169 The method of using references to dictionaries to hold methods live during linker deadcode elimination wasn't working very well. I implemented a new scheme in the CL below this, so this CL strips out the old method. The new method has the added benefit of having 0 runtime overhead (unlike the stuff we're ripping out here, which does have a small overhead). Update #48047 Change-Id: I68ac57119792d53c58f1480f407de6ab2bb53211 Reviewed-on: https://go-review.googlesource.com/c/go/+/357836 Trust: Keith Randall Trust: Dan Scales Run-TryBot: Keith Randall TryBot-Result: Go Bot Reviewed-by: Dan Scales --- src/cmd/compile/internal/noder/helpers.go | 2 +- src/cmd/compile/internal/noder/stencil.go | 20 ++++++++++---------- src/cmd/compile/internal/noder/transform.go | 15 +-------------- 3 files changed, 12 insertions(+), 25 deletions(-) diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go index adb5a0e89f..5524673e66 100644 --- a/src/cmd/compile/internal/noder/helpers.go +++ b/src/cmd/compile/internal/noder/helpers.go @@ -183,7 +183,7 @@ func Call(pos src.XPos, typ *types.Type, fun ir.Node, args []ir.Node, dots bool) // If no type params, do the normal call transformations. This // will convert OCALL to OCALLFUNC. typed(typ, n) - transformCall(n, nil) + transformCall(n) return n } diff --git a/src/cmd/compile/internal/noder/stencil.go b/src/cmd/compile/internal/noder/stencil.go index fc5b0eefd4..68032e7082 100644 --- a/src/cmd/compile/internal/noder/stencil.go +++ b/src/cmd/compile/internal/noder/stencil.go @@ -185,7 +185,7 @@ func (g *genInst) scanForGenCalls(decl ir.Node) { // it before installing the instantiation, so we are // checking against non-shape param types in // typecheckaste. - transformCall(call, nil) + transformCall(call) // Replace the OFUNCINST with a direct reference to the // new stenciled function @@ -223,7 +223,7 @@ func (g *genInst) scanForGenCalls(decl ir.Node) { // Transform the Call now, which changes OCALL // to OCALLFUNC and does typecheckaste/assignconvfn. - transformCall(call, nil) + transformCall(call) st := g.getInstantiation(gf, targs, true).fun dictValue, usingSubdict := g.getDictOrSubdict(declInfo, n, gf, targs, true) @@ -1089,14 +1089,14 @@ func (subst *subster) node(n ir.Node) ir.Node { // transform the call. call.X.(*ir.SelectorExpr).SetOp(ir.OXDOT) transformDot(call.X.(*ir.SelectorExpr), true) - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.ODOT, ir.ODOTPTR: // An OXDOT for a generic receiver was resolved to // an access to a field which has a function // value. Transform the call to that function, now // that the OXDOT was resolved. - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.ONAME: name := call.X.Name() @@ -1113,24 +1113,24 @@ func (subst *subster) node(n ir.Node) ir.Node { // This is the case of a function value that was a // type parameter (implied to be a function via a // structural constraint) which is now resolved. - transformCall(call, subst.info.dictParam) + transformCall(call) } case ir.OCLOSURE: - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.ODEREF, ir.OINDEX, ir.OINDEXMAP, ir.ORECV: // Transform a call that was delayed because of the // use of typeparam inside an expression that required // a pointer dereference, array indexing, map indexing, // or channel receive to compute function value. - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.OCALL, ir.OCALLFUNC, ir.OCALLMETH, ir.OCALLINTER: - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.OCONVNOP: - transformCall(call, subst.info.dictParam) + transformCall(call) case ir.OFUNCINST: // A call with an OFUNCINST will get transformed @@ -1276,7 +1276,7 @@ func (g *genInst) dictPass(info *instInfo) { m.(*ir.CallExpr).X.(*ir.SelectorExpr).SetOp(ir.OXDOT) transformDot(m.(*ir.CallExpr).X.(*ir.SelectorExpr), true) } - transformCall(m.(*ir.CallExpr), info.dictParam) + transformCall(m.(*ir.CallExpr)) } case ir.OCONVIFACE: diff --git a/src/cmd/compile/internal/noder/transform.go b/src/cmd/compile/internal/noder/transform.go index 29ee601d82..47e6397206 100644 --- a/src/cmd/compile/internal/noder/transform.go +++ b/src/cmd/compile/internal/noder/transform.go @@ -132,9 +132,7 @@ func transformConvCall(n *ir.CallExpr) ir.Node { // transformCall transforms a normal function/method call. Corresponds to last half // (non-conversion, non-builtin part) of typecheck.tcCall. This code should work even // in the case of OCALL/OFUNCINST. -// The dict parameter is used for OCALLINTER nodes to ensure that the called method -// is retained by the linker. -func transformCall(n *ir.CallExpr, dict *ir.Name) { +func transformCall(n *ir.CallExpr) { // n.Type() can be nil for calls with no return value assert(n.Typecheck() == 1) transformArgs(n) @@ -144,17 +142,6 @@ func transformCall(n *ir.CallExpr, dict *ir.Name) { switch l.Op() { case ir.ODOTINTER: n.SetOp(ir.OCALLINTER) - if n.X.(*ir.SelectorExpr).X.Type().HasShape() { - if dict == nil { - base.Fatalf("calls on shape interfaces need a dictionary reference") - } - dict.SetAddrtaken(true) - // KeepAlive isn't exactly the right thing here, as we only - // need to keep the dictionary live in the linker-deadcode - // sense, not the at-runtime sense. But the at-runtime sense - // is stronger, so it works. See issue 48047. - n.KeepAlive = append(n.KeepAlive, dict) - } case ir.ODOTMETH: l := l.(*ir.SelectorExpr) -- 2.50.0