Enable inlining tail calls and do not limit emitting tail calls only to the
non-inlineable methods when generating wrappers. This change produces
additional code size reduction.
Code size difference measured with this change (tried for x86_64):
etcd binary:
.text section size:
10613393 ->
10593841 (0.18%)
total binary size:
33450787 ->
33424307 (0.07%)
compile binary:
.text section size:
10171025 ->
10126545 (0.43%)
total binary size:
28241012 ->
28192628 (0.17%)
cockroach binary:
.text section size:
83947260 ->
83694140 (0.3%)
total binary size:
263799808 ->
263534160 (0.1%)
Change-Id: I694f83cb838e64bd4c51f05b7b9f2bf0193bb551
Reviewed-on: https://go-review.googlesource.com/c/go/+/650455
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: David Chase <drchase@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
Auto-Submit: Keith Randall <khr@golang.org>
ok := match(n)
- // can't wrap TailCall's child into ParenExpr
- if t, ok := n.(*ir.TailCallStmt); ok {
- ir.EditChildren(t.Call, s.mark)
- } else {
- ir.EditChildren(n, s.mark)
- }
+ ir.EditChildren(n, s.mark)
if ok {
if p == nil {
n = paren.X
}
ir.EditChildren(n, unparen)
+ // special case for tail calls: if the tail call was inlined, transform
+ // the tail call to a return stmt if the inlined function was not void,
+ // otherwise replace it with the inlined expression followed by a return.
+ if tail, ok := n.(*ir.TailCallStmt); ok {
+ if inl, done := tail.Call.(*ir.InlinedCallExpr); done {
+ if len(inl.ReturnVars) != 0 {
+ ret := ir.NewReturnStmt(tail.Pos(), []ir.Node{inl})
+ if len(inl.ReturnVars) > 1 {
+ typecheck.RewriteMultiValueCall(ret, inl)
+ }
+ n = ret
+ } else {
+ ret := ir.NewReturnStmt(tail.Pos(), nil)
+ n = ir.NewBlockStmt(tail.Pos(), []ir.Node{inl, ret})
+ }
+ }
+ }
return n
}
ir.EditChildren(s.fn, unparen)
}
func match(n ir.Node) bool {
- switch n := n.(type) {
+ switch n.(type) {
case *ir.CallExpr:
return true
- case *ir.TailCallStmt:
- n.Call.NoInline = true // can't inline yet
}
return false
}
func (n *TailCallStmt) editChildren(edit func(Node) Node) {
editNodes(n.init, edit)
if n.Call != nil {
- n.Call = edit(n.Call).(*CallExpr)
+ n.Call = edit(n.Call)
}
}
func (n *TailCallStmt) editChildrenWithHidden(edit func(Node) Node) {
editNodes(n.init, edit)
if n.Call != nil {
- n.Call = edit(n.Call).(*CallExpr)
+ n.Call = edit(n.Call)
}
}
// code generation to jump directly to another function entirely.
type TailCallStmt struct {
miniStmt
- Call *CallExpr // the underlying call
+ Call Node // the underlying call
}
func NewTailCallStmt(pos src.XPos, call *CallExpr) *TailCallStmt {
if recv.Type() != nil && recv.Type().IsPtr() && method.Type.Recv().Type.IsPtr() &&
method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) &&
- !unifiedHaveInlineBody(ir.MethodExprName(dot).Func) &&
!(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) {
if base.Debug.TailCall != 0 {
base.WarnfAt(fn.Nname.Type().Recv().Type.Elem().Pos(), "tail call emitted for the method %v wrapper", method.Nname)
}
- // Prefer OTAILCALL to reduce code size (except the case when the called method can be inlined).
+ // Prefer OTAILCALL to reduce code size (the called method can be inlined).
fn.Body.Append(ir.NewTailCallStmt(pos, call))
return
}
case ir.OTAILCALL:
n := n.(*ir.TailCallStmt)
- s.callResult(n.Call, callTail)
+ s.callResult(n.Call.(*ir.CallExpr), callTail)
call := s.mem()
b := s.endBlock()
b.Kind = ssa.BlockRetJmp // could use BlockExit. BlockRetJmp is mostly for clarity.
if cr > len(rhs) {
stmt := stmt.(*ir.AssignListStmt)
stmt.SetOp(ir.OAS2FUNC)
- r := rhs[0].(*ir.CallExpr)
+ r := rhs[0]
rtyp := r.Type()
mismatched := false
n := n.(*ir.TailCallStmt)
var init ir.Nodes
- n.Call.Fun = walkExpr(n.Call.Fun, &init)
+ call := n.Call.(*ir.CallExpr)
+ call.Fun = walkExpr(call.Fun, &init)
if len(init) > 0 {
init.Append(n)
package p
// Test that when generating wrappers for methods, we generate a tail call to the pointer version of
-// the method, if that method is not inlineable. We use go:noinline here to force the non-inlineability
-// condition.
+// the method.
-//go:noinline
-func (f *Foo) Get2Vals() [2]int { return [2]int{f.Val, f.Val + 1} }
-func (f *Foo) Get3Vals() [3]int { return [3]int{f.Val, f.Val + 1, f.Val + 2} }
+func (f *Foo) Get2Vals() [2]int { return [2]int{f.Val, f.Val + 1} }
+func (f *Foo) Get3Vals() (int, int, int) { return f.Val, f.Val + 1, f.Val + 2 }
type Foo struct{ Val int }
-type Bar struct { // ERROR "tail call emitted for the method \(\*Foo\).Get2Vals wrapper"
+type Bar struct { // ERROR "tail call emitted for the method \(\*Foo\).Get2Vals wrapper" "tail call emitted for the method \(\*Foo\).Get3Vals wrapper"
int64
*Foo // needs a method wrapper
string