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 <khr@golang.org>
Trust: Dan Scales <danscales@google.com>
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Dan Scales <danscales@google.com>

diff --git a/src/cmd/compile/internal/noder/helpers.go b/src/cmd/compile/internal/noder/helpers.go
index adb5a0e89f2e4cd2abc4371c49bd8908439ac438..5524673e6679666f2befb111f8a10ec3af680c85 100644 (file)
--- 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 fc5b0eefd4c8a44f804f07b4f0a21e1f1859011f..68032e7082be75fcb312c0f496918d28bad5aeb9 100644 (file)
--- 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 29ee601d8276f6a3e713edadd3ee6f9ece7c74d6..47e6397206d27d3e2d7966409962b2c0dd616c8e 100644 (file)
--- 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)