cmd/compile/internal/inline: extend flag calculation via export data

Extend the code that computes various properties and parameter flags
to incorporate information from export data in addition to things we
can get from the current package. Specifically:

 - when deciding whether the current function always calls panic/exit,
   check to see whether it has an unconditional call to some other
   function that has that flag.

 - when computing "parameter feeds" properties, look not just for
   cases where a parameter feeds an interesting construct (if/switch,
   indirect/interface call, etc) but where it feeds a call whose
   corresponding param has that flag.

 - when computing return properties, if a given return is always the
   results of a call to X, then set the return properties to those
   of X.

Updates #61502.

Change-Id: I6472fe98759cccad05b8eed58e4fc568201d88ad
Reviewed-on: https://go-review.googlesource.com/c/go/+/511563
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>

Author: thanm

src/cmd/compile/internal/inline/inlheur/analyze.go

@@ -104,6 +104,17 @@ func runAnalyzersOnFunction(fn *ir.Func, analyzers []propAnalyzer) {
 	doNode(fn)
 }
 
+func propsForFunc(fn *ir.Func) *FuncProps {
+	if fih, ok := fpmap[fn]; ok {
+		return fih.props
+	} else if fn.Inl != nil && fn.Inl.Properties != "" {
+		// FIXME: considering adding some sort of cache or table
+		// for deserialized properties of imported functions.
+		return DeserializeFromString(fn.Inl.Properties)
+	}
+	return nil
+}
+
 func fnFileLine(fn *ir.Func) (string, uint) {
 	p := base.Ctxt.InnermostPos(fn.Pos())
 	return filepath.Base(p.Filename()), p.Line()
@@ -176,6 +187,9 @@ func captureFuncDumpEntry(fn *ir.Func, canInline func(*ir.Func)) {
 	} else {
 		AnalyzeFunc(fn, canInline)
 		fih = fpmap[fn]
+		if fn.Inl != nil && fn.Inl.Properties == "" {
+			fn.Inl.Properties = fih.props.SerializeToString()
+		}
 	}
 	if dumpBuffer == nil {
 		dumpBuffer = make(map[*ir.Func]fnInlHeur)

src/cmd/compile/internal/inline/inlheur/analyze_func_flags.go

@@ -175,9 +175,11 @@ func isExitCall(n ir.Node) bool {
 		isWellKnownFunc(s, "runtime", "throw") {
 		return true
 	}
-	// FIXME: consult results of flags computation for
-	// previously analyzed Go functions, including props
-	// read from export data for functions in other packages.
+	if fp := propsForFunc(name.Func); fp != nil {
+		if fp.Flags&FuncPropNeverReturns != 0 {
+			return true
+		}
+	}
 	return false
 }
 

src/cmd/compile/internal/inline/inlheur/analyze_func_params.go

@@ -106,21 +106,35 @@ func (pa *paramsAnalyzer) setResults(fp *FuncProps) {
 	fp.ParamFlags = pa.values
 }
 
+func (pa *paramsAnalyzer) findParamIdx(n *ir.Name) int {
+	if n == nil {
+		panic("bad")
+	}
+	for i := range pa.params {
+		if pa.params[i] == n {
+			return i
+		}
+	}
+	return -1
+}
+
+type testfType func(x ir.Node, param *ir.Name, idx int) (bool, bool)
+
 // paramsAnalyzer invokes function 'testf' on the specified expression
 // 'x' for each parameter, and if the result is TRUE, or's 'flag' into
 // the flags for that param.
-func (pa *paramsAnalyzer) checkParams(x ir.Node, flag ParamPropBits, mayflag ParamPropBits, testf func(x ir.Node, param *ir.Name) bool) {
+func (pa *paramsAnalyzer) checkParams(x ir.Node, flag ParamPropBits, mayflag ParamPropBits, testf testfType) {
 	for idx, p := range pa.params {
 		if !pa.top[idx] && pa.values[idx] == ParamNoInfo {
 			continue
 		}
-		result := testf(x, p)
+		result, may := testf(x, p, idx)
 		if debugTrace&debugTraceParams != 0 {
 			fmt.Fprintf(os.Stderr, "=-= test expr %v param %s result=%v flag=%s\n", x, p.Sym().Name, result, flag.String())
 		}
 		if result {
 			v := flag
-			if pa.condLevel != 0 {
+			if pa.condLevel != 0 || may {
 				v = mayflag
 			}
 			pa.values[idx] |= v
@@ -134,8 +148,8 @@ func (pa *paramsAnalyzer) checkParams(x ir.Node, flag ParamPropBits, mayflag Par
 // specific parameter had a constant value.
 func (pa *paramsAnalyzer) foldCheckParams(x ir.Node) {
 	pa.checkParams(x, ParamFeedsIfOrSwitch, ParamMayFeedIfOrSwitch,
-		func(x ir.Node, p *ir.Name) bool {
-			return ShouldFoldIfNameConstant(x, []*ir.Name{p})
+		func(x ir.Node, p *ir.Name, idx int) (bool, bool) {
+			return ShouldFoldIfNameConstant(x, []*ir.Name{p}), false
 		})
 }
 
@@ -158,9 +172,9 @@ func (pa *paramsAnalyzer) callCheckParams(ce *ir.CallExpr) {
 		}
 		pa.checkParams(r, ParamFeedsInterfaceMethodCall,
 			ParamMayFeedInterfaceMethodCall,
-			func(x ir.Node, p *ir.Name) bool {
+			func(x ir.Node, p *ir.Name, idx int) (bool, bool) {
 				name := x.(*ir.Name)
-				return name == p
+				return name == p, false
 			})
 	case ir.OCALLFUNC:
 		if ce.X.Op() != ir.ONAME {
@@ -171,15 +185,89 @@ func (pa *paramsAnalyzer) callCheckParams(ce *ir.CallExpr) {
 			return
 		}
 		name := called.(*ir.Name)
+		if name.Class == ir.PPARAM {
+			pa.checkParams(called, ParamFeedsIndirectCall,
+				ParamMayFeedIndirectCall,
+				func(x ir.Node, p *ir.Name, idx int) (bool, bool) {
+					name := x.(*ir.Name)
+					return name == p, false
+				})
+		} else {
+			cname, isFunc, _ := isFuncName(called)
+			if isFunc {
+				pa.deriveFlagsFromCallee(ce, cname.Func)
+			}
+		}
+	}
+}
+
+// deriveFlagsFromCallee tries to derive flags for the current
+// function based on a call this function makes to some other
+// function. Example:
+//
+//	/* Simple */                /* Derived from callee */
+//	func foo(f func(int)) {     func foo(f func(int)) {
+//	  f(2)                        bar(32, f)
+//	}                           }
+//	                            func bar(x int, f func()) {
+//	                              f(x)
+//	                            }
+//
+// Here we can set the "param feeds indirect call" flag for
+// foo's param 'f' since we know that bar has that flag set for
+// its second param, and we're passing that param a function.
+func (pa *paramsAnalyzer) deriveFlagsFromCallee(ce *ir.CallExpr, callee *ir.Func) {
+	calleeProps := propsForFunc(callee)
+	if calleeProps == nil {
+		return
+	}
+	if debugTrace&debugTraceParams != 0 {
+		fmt.Fprintf(os.Stderr, "=-= callee props for %v:\n%s",
+			callee.Sym().Name, calleeProps.String())
+	}
+
+	must := []ParamPropBits{ParamFeedsInterfaceMethodCall, ParamFeedsIndirectCall, ParamFeedsIfOrSwitch}
+	may := []ParamPropBits{ParamMayFeedInterfaceMethodCall, ParamMayFeedIndirectCall, ParamMayFeedIfOrSwitch}
+
+	for pidx, arg := range ce.Args {
+		// Does the callee param have any interesting properties?
+		// If not we can skip this one.
+		pflag := calleeProps.ParamFlags[pidx]
+		if pflag == 0 {
+			continue
+		}
+		// See if one of the caller's parameters is flowing unmodified
+		// into this actual expression.
+		r := ir.StaticValue(arg)
+		if r.Op() != ir.ONAME {
+			return
+		}
+		name := r.(*ir.Name)
 		if name.Class != ir.PPARAM {
 			return
 		}
-		pa.checkParams(called, ParamFeedsIndirectCall,
-			ParamMayFeedIndirectCall,
-			func(x ir.Node, p *ir.Name) bool {
-				name := x.(*ir.Name)
-				return name == p
-			})
+		callerParamIdx := pa.findParamIdx(name)
+		if callerParamIdx == -1 || pa.params[callerParamIdx] == nil {
+			panic("something went wrong")
+		}
+		if !pa.top[callerParamIdx] &&
+			pa.values[callerParamIdx] == ParamNoInfo {
+			continue
+		}
+		if debugTrace&debugTraceParams != 0 {
+			fmt.Fprintf(os.Stderr, "=-= pflag for arg %d is %s\n",
+				pidx, pflag.String())
+		}
+		for i := range must {
+			mayv := may[i]
+			mustv := must[i]
+			if pflag&mustv != 0 && pa.condLevel == 0 {
+				pa.values[callerParamIdx] |= mustv
+			} else if pflag&(mustv|mayv) != 0 {
+				pa.values[callerParamIdx] |= mayv
+			}
+		}
+		pa.top[callerParamIdx] = false
 	}
 }
 

src/cmd/compile/internal/inline/inlheur/analyze_func_returns.go

@@ -28,10 +28,11 @@ type returnsAnalyzer struct {
 // the same function, etc. This container stores info on a the specific
 // scenarios we're looking for.
 type resultVal struct {
-	lit   constant.Value
-	fn    *ir.Name
-	fnClo bool
-	top   bool
+	lit     constant.Value
+	fn      *ir.Name
+	fnClo   bool
+	top     bool
+	derived bool // see deriveReturnFlagsFromCallee below
 }
 
 func makeResultsAnalyzer(fn *ir.Func, canInline func(*ir.Func)) *returnsAnalyzer {
@@ -62,7 +63,7 @@ func makeResultsAnalyzer(fn *ir.Func, canInline func(*ir.Func)) *returnsAnalyzer
 func (ra *returnsAnalyzer) setResults(fp *FuncProps) {
 	// Promote ResultAlwaysSameFunc to ResultAlwaysSameInlinableFunc
 	for i := range ra.values {
-		if ra.props[i] == ResultAlwaysSameFunc {
+		if ra.props[i] == ResultAlwaysSameFunc && !ra.values[i].derived {
 			f := ra.values[i].fn.Func
 			// If the function being returns is a closure that hasn't
 			// yet been checked by CanInline, invoke it now. NB: this
@@ -149,6 +150,7 @@ func (ra *returnsAnalyzer) analyzeResult(ii int, n ir.Node) {
 	lit, isConst := isLiteral(n)
 	rfunc, isFunc, isClo := isFuncName(n)
 	curp := ra.props[ii]
+	dprops, isDerivedFromCall := deriveReturnFlagsFromCallee(n)
 	newp := ResultNoInfo
 	var newlit constant.Value
 	var newfunc *ir.Name
@@ -172,30 +174,35 @@ func (ra *returnsAnalyzer) analyzeResult(ii int, n ir.Node) {
 		case isConst:
 			newp = ResultAlwaysSameConstant
 			newlit = lit
+		case isDerivedFromCall:
+			newp = dprops
+			ra.values[ii].derived = true
 		}
 	} else {
-		// this is not the first return we've seen; apply
-		// what amounts of a "meet" operator to combine
-		// the properties we see here with what we saw on
-		// the previous returns.
-		switch curp {
-		case ResultIsAllocatedMem:
-			if isAllocatedMem(n) {
-				newp = ResultIsAllocatedMem
-			}
-		case ResultIsConcreteTypeConvertedToInterface:
-			if isConcreteConvIface(n) {
-				newp = ResultIsConcreteTypeConvertedToInterface
-			}
-		case ResultAlwaysSameConstant:
-			if isConst && isSameLiteral(lit, ra.values[ii].lit) {
-				newp = ResultAlwaysSameConstant
-				newlit = lit
-			}
-		case ResultAlwaysSameFunc:
-			if isFunc && isSameFuncName(rfunc, ra.values[ii].fn) {
-				newp = ResultAlwaysSameFunc
-				newfunc = rfunc
+		if !ra.values[ii].derived {
+			// this is not the first return we've seen; apply
+			// what amounts of a "meet" operator to combine
+			// the properties we see here with what we saw on
+			// the previous returns.
+			switch curp {
+			case ResultIsAllocatedMem:
+				if isAllocatedMem(n) {
+					newp = ResultIsAllocatedMem
+				}
+			case ResultIsConcreteTypeConvertedToInterface:
+				if isConcreteConvIface(n) {
+					newp = ResultIsConcreteTypeConvertedToInterface
+				}
+			case ResultAlwaysSameConstant:
+				if isConst && isSameLiteral(lit, ra.values[ii].lit) {
+					newp = ResultAlwaysSameConstant
+					newlit = lit
+				}
+			case ResultAlwaysSameFunc:
+				if isFunc && isSameFuncName(rfunc, ra.values[ii].fn) {
+					newp = ResultAlwaysSameFunc
+					newfunc = rfunc
+				}
 			}
 		}
 	}
@@ -208,7 +215,6 @@ func (ra *returnsAnalyzer) analyzeResult(ii int, n ir.Node) {
 		fmt.Fprintf(os.Stderr, "=-= %v: analyzeResult newp=%s\n",
 			ir.Line(n), newp)
 	}
-
 }
 
 func isAllocatedMem(n ir.Node) bool {
@@ -220,6 +226,48 @@ func isAllocatedMem(n ir.Node) bool {
 	return false
 }
 
+// deriveReturnFlagsFromCallee tries to set properties for a given
+// return result where we're returning call expression; return value
+// is a return property value and a boolean indicating whether the
+// prop is valid. Examples:
+//
+//	func foo() int { return bar() }
+//	func bar() int { return 42 }
+//	func blix() int { return 43 }
+//	func two(y int) int {
+//	  if y < 0 { return bar() } else { return blix() }
+//	}
+//
+// Since "foo" always returns the result of a call to "bar", we can
+// set foo's return property to that of bar. In the case of "two", however,
+// even though each return path returns a constant, we don't know
+// whether the constants are identical, hence we need to be conservative.
+func deriveReturnFlagsFromCallee(n ir.Node) (ResultPropBits, bool) {
+	if n.Op() != ir.OCALLFUNC {
+		return 0, false
+	}
+	ce := n.(*ir.CallExpr)
+	if ce.X.Op() != ir.ONAME {
+		return 0, false
+	}
+	called := ir.StaticValue(ce.X)
+	if called.Op() != ir.ONAME {
+		return 0, false
+	}
+	cname, isFunc, _ := isFuncName(called)
+	if !isFunc {
+		return 0, false
+	}
+	calleeProps := propsForFunc(cname.Func)
+	if calleeProps == nil {
+		return 0, false
+	}
+	if len(calleeProps.ResultFlags) != 1 {
+		return 0, false
+	}
+	return calleeProps.ResultFlags[0], true
+}
+
 func isLiteral(n ir.Node) (constant.Value, bool) {
 	sv := ir.StaticValue(n)
 	switch sv.Op() {

src/cmd/compile/internal/inline/inlheur/funcprops_test.go

@@ -22,9 +22,9 @@ var remasterflag = flag.Bool("update-expected", false, "if true, generate update
 
 func TestFuncProperties(t *testing.T) {
 	td := t.TempDir()
-	//td = "/tmp/qqq"
-	//os.RemoveAll(td)
-	//os.Mkdir(td, 0777)
+	// td = "/tmp/qqq"
+	// os.RemoveAll(td)
+	// os.Mkdir(td, 0777)
 	testenv.MustHaveGoBuild(t)
 
 	// NOTE: this testpoint has the unfortunate characteristic that it
@@ -35,7 +35,7 @@ func TestFuncProperties(t *testing.T) {
 	// to building a fresh compiler on the fly, or using some other
 	// scheme.
 
-	testcases := []string{"funcflags", "returns", "params"}
+	testcases := []string{"funcflags", "returns", "params", "acrosscall"}
 
 	for _, tc := range testcases {
 		dumpfile, err := gatherPropsDumpForFile(t, tc, td)