[dev.link] all: merge branch 'master' into dev.linkdev.link

Clean merge.

Change-Id: Ia7b2808bc649790198d34c226a61d9e569084dc5

1 files changed, 141 insertions, 132 deletions

diff --git a/src/cmd/compile/internal/gc/inl.go b/src/cmd/compile/internal/gc/inl.go
index fa5b3ec698..a2fb00e132 100644
--- a/src/cmd/compile/internal/gc/inl.go
+++ b/src/cmd/compile/internal/gc/inl.go
@@ -7,7 +7,7 @@
 // saves a copy of the body. Then inlcalls walks each function body to
 // expand calls to inlinable functions.
 //
-// The debug['l'] flag controls the aggressiveness. Note that main() swaps level 0 and 1,
+// The Debug.l flag controls the aggressiveness. Note that main() swaps level 0 and 1,
 // making 1 the default and -l disable. Additional levels (beyond -l) may be buggy and
 // are not supported.
 //      0: disabled
@@ -21,7 +21,7 @@
 // The -d typcheckinl flag enables early typechecking of all imported bodies,
 // which is useful to flush out bugs.
 //
-// The debug['m'] flag enables diagnostic output.  a single -m is useful for verifying
+// The Debug.m flag enables diagnostic output.  a single -m is useful for verifying
 // which calls get inlined or not, more is for debugging, and may go away at any point.
 
 package gc
@@ -85,7 +85,7 @@ func typecheckinl(fn *Node) {
 		return // typecheckinl on local function
 	}
 
-	if Debug['m'] > 2 || Debug_export != 0 {
+	if Debug.m > 2 || Debug_export != 0 {
 		fmt.Printf("typecheck import [%v] %L { %#v }\n", fn.Sym, fn, asNodes(fn.Func.Inl.Body))
 	}
 
@@ -116,10 +116,10 @@ func caninl(fn *Node) {
 	}
 
 	var reason string // reason, if any, that the function was not inlined
-	if Debug['m'] > 1 || logopt.Enabled() {
+	if Debug.m > 1 || logopt.Enabled() {
 		defer func() {
 			if reason != "" {
-				if Debug['m'] > 1 {
+				if Debug.m > 1 {
 					fmt.Printf("%v: cannot inline %v: %s\n", fn.Line(), fn.Func.Nname, reason)
 				}
 				if logopt.Enabled() {
@@ -187,7 +187,7 @@ func caninl(fn *Node) {
 	defer n.Func.SetInlinabilityChecked(true)
 
 	cc := int32(inlineExtraCallCost)
-	if Debug['l'] == 4 {
+	if Debug.l == 4 {
 		cc = 1 // this appears to yield better performance than 0.
 	}
 
@@ -224,9 +224,9 @@ func caninl(fn *Node) {
 	// this is so export can find the body of a method
 	fn.Type.FuncType().Nname = asTypesNode(n)
 
-	if Debug['m'] > 1 {
+	if Debug.m > 1 {
 		fmt.Printf("%v: can inline %#v with cost %d as: %#v { %#v }\n", fn.Line(), n, inlineMaxBudget-visitor.budget, fn.Type, asNodes(n.Func.Inl.Body))
-	} else if Debug['m'] != 0 {
+	} else if Debug.m != 0 {
 		fmt.Printf("%v: can inline %v\n", fn.Line(), n)
 	}
 	if logopt.Enabled() {
@@ -325,18 +325,10 @@ func (v *hairyVisitor) visit(n *Node) bool {
 			break
 		}
 
-		if fn := n.Left.Func; fn != nil && fn.Inl != nil {
-			v.budget -= fn.Inl.Cost
+		if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
+			v.budget -= fn.Func.Inl.Cost
 			break
 		}
-		if n.Left.isMethodExpression() {
-			if d := asNode(n.Left.Sym.Def); d != nil && d.Func.Inl != nil {
-				v.budget -= d.Func.Inl.Cost
-				break
-			}
-		}
-		// TODO(mdempsky): Budget for OCLOSURE calls if we
-		// ever allow that. See #15561 and #23093.
 
 		// Call cost for non-leaf inlining.
 		v.budget -= v.extraCallCost
@@ -382,17 +374,16 @@ func (v *hairyVisitor) visit(n *Node) bool {
 		v.reason = "call to recover"
 		return true
 
+	case OCALLPART:
+		// OCALLPART is inlineable, but no extra cost to the budget
+
 	case OCLOSURE,
-		OCALLPART,
 		ORANGE,
-		OFOR,
-		OFORUNTIL,
 		OSELECT,
 		OTYPESW,
 		OGO,
 		ODEFER,
 		ODCLTYPE, // can't print yet
-		OBREAK,
 		ORETJMP:
 		v.reason = "unhandled op " + n.Op.String()
 		return true
@@ -400,10 +391,23 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	case OAPPEND:
 		v.budget -= inlineExtraAppendCost
 
-	case ODCLCONST, OEMPTY, OFALL, OLABEL:
+	case ODCLCONST, OEMPTY, OFALL:
 		// These nodes don't produce code; omit from inlining budget.
 		return false
 
+	case OLABEL:
+		// TODO(mdempsky): Add support for inlining labeled control statements.
+		if n.labeledControl() != nil {
+			v.reason = "labeled control"
+			return true
+		}
+
+	case OBREAK, OCONTINUE:
+		if n.Sym != nil {
+			// Should have short-circuited due to labeledControl above.
+			Fatalf("unexpected labeled break/continue: %v", n)
+		}
+
 	case OIF:
 		if Isconst(n.Left, CTBOOL) {
 			// This if and the condition cost nothing.
@@ -421,7 +425,7 @@ func (v *hairyVisitor) visit(n *Node) bool {
 	v.budget--
 
 	// When debugging, don't stop early, to get full cost of inlining this function
-	if v.budget < 0 && Debug['m'] < 2 && !logopt.Enabled() {
+	if v.budget < 0 && Debug.m < 2 && !logopt.Enabled() {
 		return true
 	}
 
@@ -452,7 +456,7 @@ func inlcopy(n *Node) *Node {
 	}
 
 	m := n.copy()
-	if m.Func != nil {
+	if n.Op != OCALLPART && m.Func != nil {
 		Fatalf("unexpected Func: %v", m)
 	}
 	m.Left = inlcopy(n.Left)
@@ -666,60 +670,18 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	switch n.Op {
 	case OCALLFUNC:
-		if Debug['m'] > 3 {
+		if Debug.m > 3 {
 			fmt.Printf("%v:call to func %+v\n", n.Line(), n.Left)
 		}
-		if n.Left.Func != nil && n.Left.Func.Inl != nil && !isIntrinsicCall(n) { // normal case
-			n = mkinlcall(n, n.Left, maxCost, inlMap)
-		} else if n.Left.isMethodExpression() && asNode(n.Left.Sym.Def) != nil {
-			n = mkinlcall(n, asNode(n.Left.Sym.Def), maxCost, inlMap)
-		} else if n.Left.Op == OCLOSURE {
-			if f := inlinableClosure(n.Left); f != nil {
-				n = mkinlcall(n, f, maxCost, inlMap)
-			}
-		} else if n.Left.Op == ONAME && n.Left.Name != nil && n.Left.Name.Defn != nil {
-			if d := n.Left.Name.Defn; d.Op == OAS && d.Right.Op == OCLOSURE {
-				if f := inlinableClosure(d.Right); f != nil {
-					// NB: this check is necessary to prevent indirect re-assignment of the variable
-					// having the address taken after the invocation or only used for reads is actually fine
-					// but we have no easy way to distinguish the safe cases
-					if d.Left.Name.Addrtaken() {
-						if Debug['m'] > 1 {
-							fmt.Printf("%v: cannot inline escaping closure variable %v\n", n.Line(), n.Left)
-						}
-						if logopt.Enabled() {
-							logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-								fmt.Sprintf("%v cannot be inlined (escaping closure variable)", n.Left))
-						}
-						break
-					}
-
-					// ensure the variable is never re-assigned
-					if unsafe, a := reassigned(n.Left); unsafe {
-						if Debug['m'] > 1 {
-							if a != nil {
-								fmt.Printf("%v: cannot inline re-assigned closure variable at %v: %v\n", n.Line(), a.Line(), a)
-								if logopt.Enabled() {
-									logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-										fmt.Sprintf("%v cannot be inlined (re-assigned closure variable)", a))
-								}
-							} else {
-								fmt.Printf("%v: cannot inline global closure variable %v\n", n.Line(), n.Left)
-								if logopt.Enabled() {
-									logopt.LogOpt(n.Pos, "cannotInlineCall", "inline", Curfn.funcname(),
-										fmt.Sprintf("%v cannot be inlined (global closure variable)", n.Left))
-								}
-							}
-						}
-						break
-					}
-					n = mkinlcall(n, f, maxCost, inlMap)
-				}
-			}
+		if isIntrinsicCall(n) {
+			break
+		}
+		if fn := inlCallee(n.Left); fn != nil && fn.Func.Inl != nil {
+			n = mkinlcall(n, fn, maxCost, inlMap)
 		}
 
 	case OCALLMETH:
-		if Debug['m'] > 3 {
+		if Debug.m > 3 {
 			fmt.Printf("%v:call to meth %L\n", n.Line(), n.Left.Right)
 		}
 
@@ -739,16 +701,73 @@ func inlnode(n *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	return n
 }
 
-// inlinableClosure takes an OCLOSURE node and follows linkage to the matching ONAME with
-// the inlinable body. Returns nil if the function is not inlinable.
-func inlinableClosure(n *Node) *Node {
-	c := n.Func.Closure
-	caninl(c)
-	f := c.Func.Nname
-	if f == nil || f.Func.Inl == nil {
+// inlCallee takes a function-typed expression and returns the underlying function ONAME
+// that it refers to if statically known. Otherwise, it returns nil.
+func inlCallee(fn *Node) *Node {
+	fn = staticValue(fn)
+	switch {
+	case fn.Op == ONAME && fn.Class() == PFUNC:
+		if fn.isMethodExpression() {
+			return asNode(fn.Sym.Def)
+		}
+		return fn
+	case fn.Op == OCLOSURE:
+		c := fn.Func.Closure
+		caninl(c)
+		return c.Func.Nname
+	}
+	return nil
+}
+
+func staticValue(n *Node) *Node {
+	for {
+		n1 := staticValue1(n)
+		if n1 == nil {
+			return n
+		}
+		n = n1
+	}
+}
+
+// staticValue1 implements a simple SSA-like optimization. If n is a local variable
+// that is initialized and never reassigned, staticValue1 returns the initializer
+// expression. Otherwise, it returns nil.
+func staticValue1(n *Node) *Node {
+	if n.Op != ONAME || n.Class() != PAUTO || n.Name.Addrtaken() {
+		return nil
+	}
+
+	defn := n.Name.Defn
+	if defn == nil {
+		return nil
+	}
+
+	var rhs *Node
+FindRHS:
+	switch defn.Op {
+	case OAS:
+		rhs = defn.Right
+	case OAS2:
+		for i, lhs := range defn.List.Slice() {
+			if lhs == n {
+				rhs = defn.Rlist.Index(i)
+				break FindRHS
+			}
+		}
+		Fatalf("%v missing from LHS of %v", n, defn)
+	default:
+		return nil
+	}
+	if rhs == nil {
+		Fatalf("RHS is nil: %v", defn)
+	}
+
+	unsafe, _ := reassigned(n)
+	if unsafe {
 		return nil
 	}
-	return f
+
+	return rhs
 }
 
 // reassigned takes an ONAME node, walks the function in which it is defined, and returns a boolean
@@ -831,16 +850,19 @@ func (v *reassignVisitor) visitList(l Nodes) *Node {
 	return nil
 }
 
-func tinlvar(t *types.Field, inlvars map[*Node]*Node) *Node {
-	if n := asNode(t.Nname); n != nil && !n.isBlank() {
-		inlvar := inlvars[n]
-		if inlvar == nil {
-			Fatalf("missing inlvar for %v\n", n)
-		}
-		return inlvar
+func inlParam(t *types.Field, as *Node, inlvars map[*Node]*Node) *Node {
+	n := asNode(t.Nname)
+	if n == nil || n.isBlank() {
+		return nblank
 	}
 
-	return typecheck(nblank, ctxExpr|ctxAssign)
+	inlvar := inlvars[n]
+	if inlvar == nil {
+		Fatalf("missing inlvar for %v", n)
+	}
+	as.Ninit.Append(nod(ODCL, inlvar, nil))
+	inlvar.Name.Defn = as
+	return inlvar
 }
 
 var inlgen int
@@ -889,7 +911,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	if inlMap[fn] {
-		if Debug['m'] > 1 {
+		if Debug.m > 1 {
 			fmt.Printf("%v: cannot inline %v into %v: repeated recursive cycle\n", n.Line(), fn, Curfn.funcname())
 		}
 		return n
@@ -903,12 +925,12 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 	}
 
 	// We have a function node, and it has an inlineable body.
-	if Debug['m'] > 1 {
+	if Debug.m > 1 {
 		fmt.Printf("%v: inlining call to %v %#v { %#v }\n", n.Line(), fn.Sym, fn.Type, asNodes(fn.Func.Inl.Body))
-	} else if Debug['m'] != 0 {
+	} else if Debug.m != 0 {
 		fmt.Printf("%v: inlining call to %v\n", n.Line(), fn)
 	}
-	if Debug['m'] > 2 {
+	if Debug.m > 2 {
 		fmt.Printf("%v: Before inlining: %+v\n", n.Line(), n)
 	}
 
@@ -970,14 +992,15 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 			continue
 		}
 		if ln.isParamStackCopy() { // ignore the on-stack copy of a parameter that moved to the heap
-			continue
-		}
-		inlvars[ln] = typecheck(inlvar(ln), ctxExpr)
-		if ln.Class() == PPARAM || ln.Name.Param.Stackcopy != nil && ln.Name.Param.Stackcopy.Class() == PPARAM {
-			ninit.Append(nod(ODCL, inlvars[ln], nil))
+			// TODO(mdempsky): Remove once I'm confident
+			// this never actually happens. We currently
+			// perform inlining before escape analysis, so
+			// nothing should have moved to the heap yet.
+			Fatalf("impossible: %v", ln)
 		}
+		inlf := typecheck(inlvar(ln), ctxExpr)
+		inlvars[ln] = inlf
 		if genDwarfInline > 0 {
-			inlf := inlvars[ln]
 			if ln.Class() == PPARAM {
 				inlf.Name.SetInlFormal(true)
 			} else {
@@ -1019,56 +1042,42 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 
 	// Assign arguments to the parameters' temp names.
 	as := nod(OAS2, nil, nil)
-	as.Rlist.Set(n.List.Slice())
+	as.SetColas(true)
+	if n.Op == OCALLMETH {
+		if n.Left.Left == nil {
+			Fatalf("method call without receiver: %+v", n)
+		}
+		as.Rlist.Append(n.Left.Left)
+	}
+	as.Rlist.Append(n.List.Slice()...)
 
 	// For non-dotted calls to variadic functions, we assign the
 	// variadic parameter's temp name separately.
 	var vas *Node
 
-	if fn.IsMethod() {
-		rcv := fn.Type.Recv()
-
-		if n.Left.Op == ODOTMETH {
-			// For x.M(...), assign x directly to the
-			// receiver parameter.
-			if n.Left.Left == nil {
-				Fatalf("method call without receiver: %+v", n)
-			}
-			ras := nod(OAS, tinlvar(rcv, inlvars), n.Left.Left)
-			ras = typecheck(ras, ctxStmt)
-			ninit.Append(ras)
-		} else {
-			// For T.M(...), add the receiver parameter to
-			// as.List, so it's assigned by the normal
-			// arguments.
-			if as.Rlist.Len() == 0 {
-				Fatalf("non-method call to method without first arg: %+v", n)
-			}
-			as.List.Append(tinlvar(rcv, inlvars))
-		}
+	if recv := fn.Type.Recv(); recv != nil {
+		as.List.Append(inlParam(recv, as, inlvars))
 	}
-
 	for _, param := range fn.Type.Params().Fields().Slice() {
 		// For ordinary parameters or variadic parameters in
 		// dotted calls, just add the variable to the
 		// assignment list, and we're done.
 		if !param.IsDDD() || n.IsDDD() {
-			as.List.Append(tinlvar(param, inlvars))
+			as.List.Append(inlParam(param, as, inlvars))
 			continue
 		}
 
 		// Otherwise, we need to collect the remaining values
 		// to pass as a slice.
 
-		numvals := n.List.Len()
-
 		x := as.List.Len()
-		for as.List.Len() < numvals {
+		for as.List.Len() < as.Rlist.Len() {
 			as.List.Append(argvar(param.Type, as.List.Len()))
 		}
 		varargs := as.List.Slice()[x:]
 
-		vas = nod(OAS, tinlvar(param, inlvars), nil)
+		vas = nod(OAS, nil, nil)
+		vas.Left = inlParam(param, vas, inlvars)
 		if len(varargs) == 0 {
 			vas.Right = nodnil()
 			vas.Right.Type = param.Type
@@ -1165,7 +1174,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 		}
 	}
 
-	if Debug['m'] > 2 {
+	if Debug.m > 2 {
 		fmt.Printf("%v: After inlining %+v\n\n", call.Line(), call)
 	}
 
@@ -1176,7 +1185,7 @@ func mkinlcall(n, fn *Node, maxCost int32, inlMap map[*Node]bool) *Node {
 // PAUTO's in the calling functions, and link them off of the
 // PPARAM's, PAUTOS and PPARAMOUTs of the called function.
 func inlvar(var_ *Node) *Node {
-	if Debug['m'] > 3 {
+	if Debug.m > 3 {
 		fmt.Printf("inlvar %+v\n", var_)
 	}
 
@@ -1255,13 +1264,13 @@ func (subst *inlsubst) node(n *Node) *Node {
 	switch n.Op {
 	case ONAME:
 		if inlvar := subst.inlvars[n]; inlvar != nil { // These will be set during inlnode
-			if Debug['m'] > 2 {
+			if Debug.m > 2 {
 				fmt.Printf("substituting name %+v  ->  %+v\n", n, inlvar)
 			}
 			return inlvar
 		}
 
-		if Debug['m'] > 2 {
+		if Debug.m > 2 {
 			fmt.Printf("not substituting name %+v\n", n)
 		}
 		return n