[dev.typeparams] cmd/compile: move call logic from order.go to escape

This CL moves two bits of related code from order.go to escape
analysis:

1. The recognition of "unsafe uintptr" arguments passed to
syscall-like functions.

2. The wrapping of go/defer function calls in parameter-free function
literals.

As with previous CLs, it would be nice to push this logic even further
forward, but for now escape analysis seems most pragmatic.

A couple side benefits:

1. It allows getting rid of the uintptrEscapesHack kludge.

2. When inserting wrappers, we can move some expressions into the
wrapper and escape analyze them better. For example, the test
expectation changes are all due to slice literals in go/defer calls
where the slice is now constructed at the call site, and can now be
stack allocated.

Change-Id: I73679bcad7fa8d61d2fc52d4cea0dc5ff0de8c0c
Reviewed-on: https://go-review.googlesource.com/c/go/+/330330
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Trust: Matthew Dempsky <mdempsky@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>

2 files changed, 0 insertions, 336 deletions

diff --git a/src/cmd/compile/internal/walk/order.go b/src/cmd/compile/internal/walk/order.go
index ff8e95b330..62d9b95be9 100644
--- a/src/cmd/compile/internal/walk/order.go
+++ b/src/cmd/compile/internal/walk/order.go
@@ -552,48 +552,6 @@ func (o *orderState) call(nn ir.Node) {
 
 	n.X = o.expr(n.X, nil)
 	o.exprList(n.Args)
-
-	// Pick out the function callee, if statically known.
-	// TODO(mdempsky): De-duplicate with similar code in escape analysis.
-	var callee *ir.Func
-	switch n.Op() {
-	case ir.OCALLFUNC:
-		if fn, ok := n.X.(*ir.Name); ok && fn.Op() == ir.ONAME && fn.Class == ir.PFUNC {
-			callee = fn.Func
-		}
-	case ir.OCALLMETH:
-		callee = ir.MethodExprName(n.X).Func
-	}
-
-	if callee == nil || callee.Pragma&ir.UintptrKeepAlive == 0 {
-		return
-	}
-
-	keepAlive := func(args []ir.Node) {
-		// If the argument is really a pointer being converted to uintptr,
-		// arrange for the pointer to be kept alive until the call returns,
-		// by copying it into a temp and marking that temp
-		// still alive when we pop the temp stack.
-		for _, arg := range args {
-			if arg.Op() == ir.OCONVNOP && arg.Type().IsUintptr() {
-				arg := arg.(*ir.ConvExpr)
-				if arg.X.Type().IsUnsafePtr() {
-					x := o.copyExpr(arg.X)
-					arg.X = x
-					x.SetAddrtaken(true) // ensure SSA keeps the x variable
-					n.KeepAlive = append(n.KeepAlive, x)
-				}
-			}
-		}
-	}
-
-	last := len(n.Args) - 1
-	if n.IsDDD && n.Args[last].Op() == ir.OSLICELIT {
-		keepAlive(n.Args[:last])
-		keepAlive(n.Args[last].(*ir.CompLitExpr).List)
-	} else {
-		keepAlive(n.Args)
-	}
 }
 
 // mapAssign appends n to o.out.
@@ -790,7 +748,6 @@ func (o *orderState) stmt(n ir.Node) {
 		t := o.markTemp()
 		o.init(n.Call)
 		o.call(n.Call)
-		o.wrapGoDefer(n)
 		o.out = append(o.out, n)
 		o.cleanTemp(t)
 
@@ -1486,280 +1443,6 @@ func (o *orderState) as2ok(n *ir.AssignListStmt) {
 	o.stmt(typecheck.Stmt(as))
 }
 
-var wrapGoDefer_prgen int
-
-// wrapGoDefer wraps the target of a "go" or "defer" statement with a
-// new "function with no arguments" closure. Specifically, it converts
-//
-//   defer f(x, y)
-//
-// to
-//
-//   x1, y1 := x, y
-//   defer func() { f(x1, y1) }()
-//
-// This is primarily to enable a quicker bringup of defers under the
-// new register ABI; by doing this conversion, we can simplify the
-// code in the runtime that invokes defers on the panic path.
-func (o *orderState) wrapGoDefer(n *ir.GoDeferStmt) {
-	call := n.Call
-
-	var callX ir.Node        // thing being called
-	var callArgs []ir.Node   // call arguments
-	var keepAlive []*ir.Name // KeepAlive list from call, if present
-
-	// A helper to recreate the call within the closure.
-	var mkNewCall func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node
-
-	// Defer calls come in many shapes and sizes; not all of them
-	// are ir.CallExpr's. Examine the type to see what we're dealing with.
-	switch x := call.(type) {
-	case *ir.CallExpr:
-		callX = x.X
-		callArgs = x.Args
-		keepAlive = x.KeepAlive
-		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
-			newcall := ir.NewCallExpr(pos, op, fun, args)
-			newcall.IsDDD = x.IsDDD
-			return ir.Node(newcall)
-		}
-	case *ir.UnaryExpr: // ex: OCLOSE
-		callArgs = []ir.Node{x.X}
-		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
-			if len(args) != 1 {
-				panic("internal error, expecting single arg")
-			}
-			return ir.Node(ir.NewUnaryExpr(pos, op, args[0]))
-		}
-	case *ir.BinaryExpr: // ex: OCOPY
-		callArgs = []ir.Node{x.X, x.Y}
-		mkNewCall = func(pos src.XPos, op ir.Op, fun ir.Node, args []ir.Node) ir.Node {
-			if len(args) != 2 {
-				panic("internal error, expecting two args")
-			}
-			return ir.Node(ir.NewBinaryExpr(pos, op, args[0], args[1]))
-		}
-	default:
-		panic("unhandled op")
-	}
-
-	// No need to wrap if called func has no args, no receiver, and no results.
-	// However in the case of "defer func() { ... }()" we need to
-	// protect against the possibility of directClosureCall rewriting
-	// things so that the call does have arguments.
-	//
-	// Do wrap method calls (OCALLMETH, OCALLINTER), because it has
-	// a receiver.
-	//
-	// Also do wrap builtin functions, because they may be expanded to
-	// calls with arguments (e.g. ORECOVER).
-	//
-	// TODO: maybe not wrap if the called function has no arguments and
-	// only in-register results?
-	if len(callArgs) == 0 && call.Op() == ir.OCALLFUNC && callX.Type().NumResults() == 0 {
-		if callX.Op() == ir.OCLOSURE {
-			clo := callX.(*ir.ClosureExpr)
-			clo.IsGoWrap = true
-		}
-		return
-	}
-
-	if c, ok := call.(*ir.CallExpr); ok {
-		// To simplify things, turn f(a, b, []T{c, d, e}...) back
-		// into f(a, b, c, d, e) -- when the final call is run through the
-		// type checker below, it will rebuild the proper slice literal.
-		undoVariadic(c)
-		callX = c.X
-		callArgs = c.Args
-	}
-
-	// This is set to true if the closure we're generating escapes
-	// (needs heap allocation).
-	cloEscapes := func() bool {
-		if n.Op() == ir.OGO {
-			// For "go", assume that all closures escape.
-			return true
-		}
-		// For defer, just use whatever result escape analysis
-		// has determined for the defer.
-		return n.Esc() != ir.EscNever
-	}()
-
-	// A helper for making a copy of an argument. Note that it is
-	// not safe to use o.copyExpr(arg) if we're putting a
-	// reference to the temp into the closure (as opposed to
-	// copying it in by value), since in the by-reference case we
-	// need a temporary whose lifetime extends to the end of the
-	// function (as opposed to being local to the current block or
-	// statement being ordered).
-	mkArgCopy := func(arg ir.Node) *ir.Name {
-		t := arg.Type()
-		byval := t.Size() <= 128 || cloEscapes
-		var argCopy *ir.Name
-		if byval {
-			argCopy = o.copyExpr(arg)
-		} else {
-			argCopy = typecheck.Temp(t)
-			o.append(ir.NewAssignStmt(base.Pos, argCopy, arg))
-		}
-		// The value of 128 below is meant to be consistent with code
-		// in escape analysis that picks byval/byaddr based on size.
-		argCopy.SetByval(byval)
-		return argCopy
-	}
-
-	// getUnsafeArg looks for an unsafe.Pointer arg that has been
-	// previously captured into the call's keepalive list, returning
-	// the name node for it if found.
-	getUnsafeArg := func(arg ir.Node) *ir.Name {
-		// Look for uintptr(unsafe.Pointer(name))
-		if arg.Op() != ir.OCONVNOP {
-			return nil
-		}
-		if !arg.Type().IsUintptr() {
-			return nil
-		}
-		if !arg.(*ir.ConvExpr).X.Type().IsUnsafePtr() {
-			return nil
-		}
-		arg = arg.(*ir.ConvExpr).X
-		argname, ok := arg.(*ir.Name)
-		if !ok {
-			return nil
-		}
-		for i := range keepAlive {
-			if argname == keepAlive[i] {
-				return argname
-			}
-		}
-		return nil
-	}
-
-	// Copy the arguments to the function into temps.
-	//
-	// For calls with uintptr(unsafe.Pointer(...)) args that are being
-	// kept alive (see code in (*orderState).call that does this), use
-	// the existing arg copy instead of creating a new copy.
-	unsafeArgs := make([]*ir.Name, len(callArgs))
-	origArgs := callArgs
-	var newNames []*ir.Name
-	for i := range callArgs {
-		arg := callArgs[i]
-		var argname *ir.Name
-		unsafeArgName := getUnsafeArg(arg)
-		if unsafeArgName != nil {
-			// arg has been copied already, use keepalive copy
-			argname = unsafeArgName
-			unsafeArgs[i] = unsafeArgName
-		} else {
-			argname = mkArgCopy(arg)
-		}
-		newNames = append(newNames, argname)
-	}
-
-	// Deal with cases where the function expression (what we're
-	// calling) is not a simple function symbol.
-	var fnExpr *ir.Name
-	var methSelectorExpr *ir.SelectorExpr
-	if callX != nil {
-		switch {
-		case callX.Op() == ir.ODOTMETH || callX.Op() == ir.ODOTINTER:
-			// Handle defer of a method call, e.g. "defer v.MyMethod(x, y)"
-			n := callX.(*ir.SelectorExpr)
-			n.X = mkArgCopy(n.X)
-			methSelectorExpr = n
-			if callX.Op() == ir.ODOTINTER {
-				// Currently for "defer i.M()" if i is nil it panics at the
-				// point of defer statement, not when deferred function is called.
-				// (I think there is an issue discussing what is the intended
-				// behavior but I cannot find it.)
-				// We need to do the nil check outside of the wrapper.
-				tab := typecheck.Expr(ir.NewUnaryExpr(base.Pos, ir.OITAB, n.X))
-				c := ir.NewUnaryExpr(n.Pos(), ir.OCHECKNIL, tab)
-				c.SetTypecheck(1)
-				o.append(c)
-			}
-		case !(callX.Op() == ir.ONAME && callX.(*ir.Name).Class == ir.PFUNC):
-			// Deal with "defer returnsafunc()(x, y)" (for
-			// example) by copying the callee expression.
-			fnExpr = mkArgCopy(callX)
-		}
-	}
-
-	// Create a new no-argument function that we'll hand off to defer.
-	fn := ir.NewClosureFunc(base.Pos, true)
-	fn.Nname.SetType(types.NewSignature(types.LocalPkg, nil, nil, nil, nil))
-	fn.SetWrapper(true)
-
-	// helper for capturing reference to a var declared in an outer scope.
-	capName := func(pos src.XPos, fn *ir.Func, n *ir.Name) *ir.Name {
-		t := n.Type()
-		cv := ir.CaptureName(pos, fn, n)
-		cv.SetType(t)
-		return typecheck.Expr(cv).(*ir.Name)
-	}
-
-	// Call args (x1, y1) need to be captured as part of the newly
-	// created closure.
-	newCallArgs := []ir.Node{}
-	for i := range newNames {
-		var arg ir.Node
-		arg = capName(callArgs[i].Pos(), fn, newNames[i])
-		if unsafeArgs[i] != nil {
-			arg = ir.NewConvExpr(arg.Pos(), origArgs[i].Op(), origArgs[i].Type(), arg)
-		}
-		newCallArgs = append(newCallArgs, arg)
-	}
-	// Also capture the function or method expression (if needed) into
-	// the closure.
-	if fnExpr != nil {
-		callX = capName(callX.Pos(), fn, fnExpr)
-	}
-	if methSelectorExpr != nil {
-		methSelectorExpr.X = capName(callX.Pos(), fn, methSelectorExpr.X.(*ir.Name))
-	}
-
-	// This flags a builtin as opposed to a regular call.
-	irregular := (call.Op() != ir.OCALLFUNC &&
-		call.Op() != ir.OCALLMETH &&
-		call.Op() != ir.OCALLINTER)
-
-	// Construct new function body:  f(x1, y1)
-	op := ir.OCALL
-	if irregular {
-		op = call.Op()
-	}
-	newcall := mkNewCall(call.Pos(), op, callX, newCallArgs)
-
-	// Finalize body, register function on the main decls list.
-	fn.Body = []ir.Node{newcall}
-	ir.FinishCaptureNames(n.Pos(), ir.CurFunc, fn)
-
-	// Create closure expr
-	clo := typecheck.Expr(fn.OClosure).(*ir.ClosureExpr)
-
-	// Set escape properties for closure.
-	if n.Op() == ir.OGO {
-		// For "go", assume that the closure is going to escape.
-		clo.SetEsc(ir.EscHeap)
-		clo.IsGoWrap = true
-	} else {
-		// For defer, just use whatever result escape analysis
-		// has determined for the defer.
-		if n.Esc() == ir.EscNever {
-			clo.SetTransient(true)
-			clo.SetEsc(ir.EscNone)
-		}
-	}
-
-	// Create new top level call to closure over argless function.
-	topcall := ir.NewCallExpr(n.Pos(), ir.OCALL, clo, nil)
-	typecheck.Call(topcall)
-
-	// Finally, point the defer statement at the newly generated call.
-	n.Call = topcall
-}
-
 // isFuncPCIntrinsic returns whether n is a direct call of internal/abi.FuncPCABIxxx functions.
 func isFuncPCIntrinsic(n *ir.CallExpr) bool {
 	if n.Op() != ir.OCALLFUNC || n.X.Op() != ir.ONAME {
diff --git a/src/cmd/compile/internal/walk/stmt.go b/src/cmd/compile/internal/walk/stmt.go
index bcc0a3e517..0c216d2e8a 100644
--- a/src/cmd/compile/internal/walk/stmt.go
+++ b/src/cmd/compile/internal/walk/stmt.go
@@ -222,22 +222,3 @@ func walkIf(n *ir.IfStmt) ir.Node {
 	walkStmtList(n.Else)
 	return n
 }
-
-// undoVariadic turns a call to a variadic function of the form
-//
-//      f(a, b, []T{c, d, e}...)
-//
-// back into
-//
-//      f(a, b, c, d, e)
-//
-func undoVariadic(call *ir.CallExpr) {
-	if call.IsDDD {
-		last := len(call.Args) - 1
-		if va := call.Args[last]; va.Op() == ir.OSLICELIT {
-			va := va.(*ir.CompLitExpr)
-			call.Args = append(call.Args[:last], va.List...)
-			call.IsDDD = false
-		}
-	}
-}