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 adb5a0e..5524673 100644
--- a/src/cmd/compile/internal/noder/helpers.go
+++ b/src/cmd/compile/internal/noder/helpers.go
@@ -183,7 +183,7 @@
// 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 fc5b0ee..68032e7 100644
--- a/src/cmd/compile/internal/noder/stencil.go
+++ b/src/cmd/compile/internal/noder/stencil.go
@@ -185,7 +185,7 @@
// 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 @@
// 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 @@
// 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 @@
// 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 @@
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 29ee601..47e6397 100644
--- a/src/cmd/compile/internal/noder/transform.go
+++ b/src/cmd/compile/internal/noder/transform.go
@@ -132,9 +132,7 @@
// 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 @@
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)
