cmd/compile/internal/inline: build call site table

Build up a table of (potentially) inlinable call sites during inline
heuristic analysis, and introduce a framework for analyzing each call
site to collect applicable flags (for example, is call nested in
loop). This patch doesn't include any of the flag analysis, just the
machinery to collect the callsites and a regression test harness.

Updates #61502.

Change-Id: Ieaf4a008ac9868e9762c63f5b59bd264dc71ab30
Reviewed-on: https://go-review.googlesource.com/c/go/+/511564
Reviewed-by: Matthew Dempsky <[email protected]>
LUCI-TryBot-Result: Go LUCI <[email protected]>

Author: thanm

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

@@ -23,6 +23,7 @@ const (
 	debugTraceResults
 	debugTraceParams
 	debugTraceExprClassify
+	debugTraceCalls
 )
 
 // propAnalyzer interface is used for defining one or more analyzer
@@ -40,13 +41,19 @@ type propAnalyzer interface {
 	setResults(fp *FuncProps)
 }
 
-// fnInlHeur contains inline heuristics state information about
-// a specific Go function being analyzed/considered by the inliner.
+// fnInlHeur contains inline heuristics state information about a
+// specific Go function being analyzed/considered by the inliner. Note
+// that in addition to constructing a fnInlHeur object by analyzing a
+// specific *ir.Func, there is also code in the test harness
+// (funcprops_test.go) that builds up fnInlHeur's by reading in and
+// parsing a dump. This is the reason why we have file/fname/line
+// fields below instead of just an *ir.Func field.
 type fnInlHeur struct {
 	fname string
 	file  string
 	line  uint
 	props *FuncProps
+	cstab CallSiteTab
 }
 
 var fpmap = map[*ir.Func]fnInlHeur{}
@@ -55,13 +62,18 @@ func AnalyzeFunc(fn *ir.Func, canInline func(*ir.Func)) *FuncProps {
 	if fih, ok := fpmap[fn]; ok {
 		return fih.props
 	}
-	fp := computeFuncProps(fn, canInline)
+	fp, fcstab := computeFuncProps(fn, canInline)
 	file, line := fnFileLine(fn)
 	entry := fnInlHeur{
 		fname: fn.Sym().Name,
 		file:  file,
 		line:  line,
 		props: fp,
+		cstab: fcstab,
+	}
+	// Merge this functions call sites into the package level table.
+	if err := cstab.merge(fcstab); err != nil {
+		base.FatalfAt(fn.Pos(), "%v", err)
 	}
 	fpmap[fn] = entry
 	return fp
@@ -70,7 +82,7 @@ func AnalyzeFunc(fn *ir.Func, canInline func(*ir.Func)) *FuncProps {
 // computeFuncProps examines the Go function 'fn' and computes for it
 // a function "properties" object, to be used to drive inlining
 // heuristics. See comments on the FuncProps type for more info.
-func computeFuncProps(fn *ir.Func, canInline func(*ir.Func)) *FuncProps {
+func computeFuncProps(fn *ir.Func, canInline func(*ir.Func)) (*FuncProps, CallSiteTab) {
 	enableDebugTraceIfEnv()
 	if debugTrace&debugTraceFuncs != 0 {
 		fmt.Fprintf(os.Stderr, "=-= starting analysis of func %v:\n%+v\n",
@@ -85,8 +97,10 @@ func computeFuncProps(fn *ir.Func, canInline func(*ir.Func)) *FuncProps {
 	for _, a := range analyzers {
 		a.setResults(fp)
 	}
+	// Now build up a partial table of callsites for this func.
+	cstab := computeCallSiteTable(fn)
 	disableDebugTrace()
-	return fp
+	return fp, cstab
 }
 
 func runAnalyzersOnFunction(fn *ir.Func, analyzers []propAnalyzer) {
@@ -164,7 +178,7 @@ func emitDumpToFile(dumpfile string) {
 		}
 		prevline = entry.line
 		atl := atline[entry.line]
-		if err := dumpFnPreamble(outf, &entry, idx, atl); err != nil {
+		if err := dumpFnPreamble(outf, &entry, nil, idx, atl); err != nil {
 			base.Fatalf("function props dump: %v\n", err)
 		}
 	}
@@ -211,11 +225,11 @@ func dumpFilePreamble(w io.Writer) {
 	fmt.Fprintf(w, "// %s\n", preambleDelimiter)
 }
 
-// dumpFilePreamble writes out a function-level preamble for a given
+// dumpFnPreamble writes out a function-level preamble for a given
 // Go function as part of a function properties dump. See the
 // README.txt file in testdata/props for more on the format of
 // this preamble.
-func dumpFnPreamble(w io.Writer, fih *fnInlHeur, idx, atl uint) error {
+func dumpFnPreamble(w io.Writer, fih *fnInlHeur, ecst encodedCallSiteTab, idx, atl uint) error {
 	fmt.Fprintf(w, "// %s %s %d %d %d\n",
 		fih.file, fih.fname, fih.line, idx, atl)
 	// emit props as comments, followed by delimiter
@@ -224,7 +238,9 @@ func dumpFnPreamble(w io.Writer, fih *fnInlHeur, idx, atl uint) error {
 	if err != nil {
 		return fmt.Errorf("marshall error %v\n", err)
 	}
-	fmt.Fprintf(w, "// %s\n// %s\n", string(data), fnDelimiter)
+	fmt.Fprintf(w, "// %s\n", string(data))
+	dumpCallSiteComments(w, fih.cstab, ecst)
+	fmt.Fprintf(w, "// %s\n", fnDelimiter)
 	return nil
 }
 
@@ -245,6 +261,7 @@ func sortFnInlHeurSlice(sl []fnInlHeur) []fnInlHeur {
 const preambleDelimiter = "<endfilepreamble>"
 const fnDelimiter = "<endfuncpreamble>"
 const comDelimiter = "<endpropsdump>"
+const csDelimiter = "<endcallsites>"
 
 // dumpBuffer stores up function properties dumps when
 // "-d=dumpinlfuncprops=..." is in effect.

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

@@ -0,0 +1,154 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package inlheur
+
+import (
+	"cmd/compile/internal/ir"
+	"cmd/compile/internal/pgo"
+	"fmt"
+	"os"
+)
+
+type callSiteAnalyzer struct {
+	cstab  CallSiteTab
+	nstack []ir.Node
+}
+
+func makeCallSiteAnalyzer(fn *ir.Func) *callSiteAnalyzer {
+	return &callSiteAnalyzer{
+		cstab: make(CallSiteTab),
+	}
+}
+
+func computeCallSiteTable(fn *ir.Func) CallSiteTab {
+	if debugTrace&debugTraceCalls != 0 {
+		fmt.Fprintf(os.Stderr, "=-= making callsite table for func %v:\n",
+			fn.Sym().Name)
+	}
+	csa := makeCallSiteAnalyzer(fn)
+	var doNode func(ir.Node) bool
+	doNode = func(n ir.Node) bool {
+		csa.nodeVisitPre(n)
+		ir.DoChildren(n, doNode)
+		csa.nodeVisitPost(n)
+		return false
+	}
+	doNode(fn)
+	return csa.cstab
+}
+
+func (csa *callSiteAnalyzer) flagsForNode(call *ir.CallExpr) CSPropBits {
+	return 0
+}
+
+func (csa *callSiteAnalyzer) addCallSite(callee *ir.Func, call *ir.CallExpr) {
+	// FIXME: maybe bulk-allocate these?
+	cs := &CallSite{
+		Call:   call,
+		Callee: callee,
+		Assign: csa.containingAssignment(call),
+		Flags:  csa.flagsForNode(call),
+		Id:     uint(len(csa.cstab)),
+	}
+	if _, ok := csa.cstab[call]; ok {
+		fmt.Fprintf(os.Stderr, "*** cstab duplicate entry at: %s\n",
+			fmtFullPos(call.Pos()))
+		fmt.Fprintf(os.Stderr, "*** call: %+v\n", call)
+		panic("bad")
+	}
+	if debugTrace&debugTraceCalls != 0 {
+		fmt.Fprintf(os.Stderr, "=-= added callsite: callee=%s call=%v\n",
+			callee.Sym().Name, callee)
+	}
+
+	csa.cstab[call] = cs
+}
+
+func (csa *callSiteAnalyzer) nodeVisitPre(n ir.Node) {
+	switch n.Op() {
+	case ir.OCALLFUNC:
+		ce := n.(*ir.CallExpr)
+		callee := pgo.DirectCallee(ce.X)
+		if callee != nil && callee.Inl != nil {
+			csa.addCallSite(callee, ce)
+		}
+	}
+	csa.nstack = append(csa.nstack, n)
+}
+
+func (csa *callSiteAnalyzer) nodeVisitPost(n ir.Node) {
+	csa.nstack = csa.nstack[:len(csa.nstack)-1]
+}
+
+// containingAssignment returns the top-level assignment statement
+// for a statement level function call "n". Examples:
+//
+//	x := foo()
+//	x, y := bar(z, baz())
+//	if blah() { ...
+//
+// Here the top-level assignment statement for the foo() call is the
+// statement assigning to "x"; the top-level assignment for "bar()"
+// call is the assignment to x,y.   For the baz() and blah() calls,
+// there is no top level assignment statement.
+//
+// The unstated goal here is that we want to use the containing assignment
+// to establish a connection between a given call and the variables
+// to which its results/returns are being assigned.
+//
+// Note that for the "bar" command above, the front end sometimes
+// decomposes this into two assignments, the first one assigning the
+// call to a pair of auto-temps, then the second one assigning the
+// auto-temps to the user-visible vars. This helper will return the
+// second (outer) of these two.
+func (csa *callSiteAnalyzer) containingAssignment(n ir.Node) ir.Node {
+	parent := csa.nstack[len(csa.nstack)-1]
+
+	// assignsOnlyAutoTemps returns TRUE of the specified OAS2FUNC
+	// node assigns only auto-temps.
+	assignsOnlyAutoTemps := func(x ir.Node) bool {
+		alst := x.(*ir.AssignListStmt)
+		oa2init := alst.Init()
+		if len(oa2init) == 0 {
+			return false
+		}
+		for _, v := range oa2init {
+			d := v.(*ir.Decl)
+			if !ir.IsAutoTmp(d.X) {
+				return false
+			}
+		}
+		return true
+	}
+
+	// Simple case: x := foo()
+	if parent.Op() == ir.OAS {
+		return parent
+	}
+
+	// Multi-return case: x, y := bar()
+	if parent.Op() == ir.OAS2FUNC {
+		// Hack city: if the result vars are auto-temps, try looking
+		// for an outer assignment in the tree. The code shape we're
+		// looking for here is:
+		//
+		// OAS1({x,y},OCONVNOP(OAS2FUNC({auto1,auto2},OCALLFUNC(bar))))
+		//
+		if assignsOnlyAutoTemps(parent) {
+			par2 := csa.nstack[len(csa.nstack)-2]
+			if par2.Op() == ir.OAS2 {
+				return par2
+			}
+			if par2.Op() == ir.OCONVNOP {
+				par3 := csa.nstack[len(csa.nstack)-3]
+				if par3.Op() == ir.OAS2 {
+					return par3
+				}
+			}
+		}
+	}
+
+	return nil
+}

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

@@ -0,0 +1,115 @@
+// Copyright 2023 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package inlheur
+
+import (
+	"cmd/compile/internal/base"
+	"cmd/compile/internal/ir"
+	"cmd/internal/src"
+	"fmt"
+	"io"
+	"path/filepath"
+	"sort"
+	"strings"
+)
+
+// CallSite records useful information about a potentially inlinable
+// (direct) function call. "Callee" is the target of the call, "Call"
+// is the ir node corresponding to the call itself, "Assign" is
+// the top-level assignment statement containing the call (if the call
+// appears in the form of a top-level statement, e.g. "x := foo()"),
+// "Flags" contains properties of the call that might be useful for
+// making inlining decisions, "Score" is the final score assigned to
+// the site, and "Id" is a numeric ID for the site within its
+// containing function.
+type CallSite struct {
+	Callee *ir.Func
+	Call   *ir.CallExpr
+	Assign ir.Node
+	Flags  CSPropBits
+	Score  int
+	Id     uint
+}
+
+// CallSiteTab is a table of call sites, keyed by call expr.
+// Ideally it would be nice to key the table by src.XPos, but
+// this results in collisions for calls on very long lines (the
+// front end saturates column numbers at 255). We also wind up
+// with many calls that share the same auto-generated pos.
+type CallSiteTab map[*ir.CallExpr]*CallSite
+
+// Package-level table of callsites.
+var cstab = CallSiteTab{}
+
+type CSPropBits uint32
+
+const (
+	CallSiteInLoop CSPropBits = 1 << iota
+	CallSiteOnPanicPath
+	CallSiteInInitFunc
+)
+
+// encodedCallSiteTab is a table keyed by "encoded" callsite
+// (stringified src.XPos plus call site ID) mapping to a value of call
+// property bits.
+type encodedCallSiteTab map[string]CSPropBits
+
+func (cst CallSiteTab) merge(other CallSiteTab) error {
+	for k, v := range other {
+		if prev, ok := cst[k]; ok {
+			return fmt.Errorf("internal error: collision during call site table merge, fn=%s callsite=%s", prev.Callee.Sym().Name, fmtFullPos(prev.Call.Pos()))
+		}
+		cst[k] = v
+	}
+	return nil
+}
+
+func fmtFullPos(p src.XPos) string {
+	var sb strings.Builder
+	sep := ""
+	base.Ctxt.AllPos(p, func(pos src.Pos) {
+		fmt.Fprintf(&sb, sep)
+		sep = "|"
+		file := filepath.Base(pos.Filename())
+		fmt.Fprintf(&sb, "%s:%d:%d", file, pos.Line(), pos.Col())
+	})
+	return sb.String()
+}
+
+func encodeCallSiteKey(cs *CallSite) string {
+	var sb strings.Builder
+	// FIXME: rewrite line offsets relative to function start
+	sb.WriteString(fmtFullPos(cs.Call.Pos()))
+	fmt.Fprintf(&sb, "|%d", cs.Id)
+	return sb.String()
+}
+
+func buildEncodedCallSiteTab(tab CallSiteTab) encodedCallSiteTab {
+	r := make(encodedCallSiteTab)
+	for _, cs := range tab {
+		k := encodeCallSiteKey(cs)
+		r[k] = cs.Flags
+	}
+	return r
+}
+
+// dumpCallSiteComments emits comments into the dump file for the
+// callsites in the function of interest. If "ecst" is non-nil, we use
+// that, otherwise generated a fresh encodedCallSiteTab from "tab".
+func dumpCallSiteComments(w io.Writer, tab CallSiteTab, ecst encodedCallSiteTab) {
+	if ecst == nil {
+		ecst = buildEncodedCallSiteTab(tab)
+	}
+	tags := make([]string, 0, len(ecst))
+	for k := range ecst {
+		tags = append(tags, k)
+	}
+	sort.Strings(tags)
+	for _, s := range tags {
+		v := ecst[s]
+		fmt.Fprintf(w, "// callsite: %s flagstr %q flagval %d\n", s, v.String(), v)
+	}
+	fmt.Fprintf(w, "// %s\n", csDelimiter)
+}