1 // Copyright 2023 The Go Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style
3 // license that can be found in the LICENSE file.
8 "cmd/compile/internal/base"
9 "cmd/compile/internal/ir"
10 "cmd/compile/internal/types"
13 "internal/goexperiment"
22 debugTraceFuncs = 1 << iota
26 debugTraceExprClassify
31 // propAnalyzer interface is used for defining one or more analyzer
32 // helper objects, each tasked with computing some specific subset of
33 // the properties we're interested in. The assumption is that
34 // properties are independent, so each new analyzer that implements
35 // this interface can operate entirely on its own. For a given analyzer
36 // there will be a sequence of calls to nodeVisitPre and nodeVisitPost
37 // as the nodes within a function are visited, then a followup call to
38 // setResults so that the analyzer can transfer its results into the
39 // final properties object.
40 type propAnalyzer interface {
41 nodeVisitPre(n ir.Node)
42 nodeVisitPost(n ir.Node)
43 setResults(fp *FuncProps)
46 // fnInlHeur contains inline heuristics state information about a
47 // specific Go function being analyzed/considered by the inliner. Note
48 // that in addition to constructing a fnInlHeur object by analyzing a
49 // specific *ir.Func, there is also code in the test harness
50 // (funcprops_test.go) that builds up fnInlHeur's by reading in and
51 // parsing a dump. This is the reason why we have file/fname/line
52 // fields below instead of just an *ir.Func field.
53 type fnInlHeur struct {
62 var fpmap = map[*ir.Func]fnInlHeur{}
64 func AnalyzeFunc(fn *ir.Func, canInline func(*ir.Func), inlineMaxBudget int32) *FuncProps {
65 if fih, ok := fpmap[fn]; ok {
68 fp, fcstab := computeFuncProps(fn, canInline, inlineMaxBudget)
69 file, line := fnFileLine(fn)
74 inlineMaxBudget: inlineMaxBudget,
78 // Merge this functions call sites into the package level table.
79 if err := cstab.merge(fcstab); err != nil {
80 base.FatalfAt(fn.Pos(), "%v", err)
82 fn.SetNeverReturns(entry.props.Flags&FuncPropNeverReturns != 0)
84 if fn.Inl != nil && fn.Inl.Properties == "" {
85 fn.Inl.Properties = entry.props.SerializeToString()
90 // computeFuncProps examines the Go function 'fn' and computes for it
91 // a function "properties" object, to be used to drive inlining
92 // heuristics. See comments on the FuncProps type for more info.
93 func computeFuncProps(fn *ir.Func, canInline func(*ir.Func), inlineMaxBudget int32) (*FuncProps, CallSiteTab) {
94 enableDebugTraceIfEnv()
95 if debugTrace&debugTraceFuncs != 0 {
96 fmt.Fprintf(os.Stderr, "=-= starting analysis of func %v:\n%+v\n",
99 ra := makeResultsAnalyzer(fn, canInline, inlineMaxBudget)
100 pa := makeParamsAnalyzer(fn)
101 ffa := makeFuncFlagsAnalyzer(fn)
102 analyzers := []propAnalyzer{ffa, ra, pa}
104 runAnalyzersOnFunction(fn, analyzers)
105 for _, a := range analyzers {
108 // Now build up a partial table of callsites for this func.
109 cstab := computeCallSiteTable(fn, ffa.panicPathTable())
114 func runAnalyzersOnFunction(fn *ir.Func, analyzers []propAnalyzer) {
115 var doNode func(ir.Node) bool
116 doNode = func(n ir.Node) bool {
117 for _, a := range analyzers {
120 ir.DoChildren(n, doNode)
121 for _, a := range analyzers {
129 func propsForFunc(fn *ir.Func) *FuncProps {
130 if fih, ok := fpmap[fn]; ok {
132 } else if fn.Inl != nil && fn.Inl.Properties != "" {
133 // FIXME: considering adding some sort of cache or table
134 // for deserialized properties of imported functions.
135 return DeserializeFromString(fn.Inl.Properties)
140 func fnFileLine(fn *ir.Func) (string, uint) {
141 p := base.Ctxt.InnermostPos(fn.Pos())
142 return filepath.Base(p.Filename()), p.Line()
145 func UnitTesting() bool {
146 return base.Debug.DumpInlFuncProps != ""
149 // DumpFuncProps computes and caches function properties for the func
150 // 'fn' and any closures it contains, or if fn is nil, it writes out the
151 // cached set of properties to the file given in 'dumpfile'. Used for
152 // the "-d=dumpinlfuncprops=..." command line flag, intended for use
153 // primarily in unit testing.
154 func DumpFuncProps(fn *ir.Func, dumpfile string, canInline func(*ir.Func), inlineMaxBudget int32) {
156 enableDebugTraceIfEnv()
157 dmp := func(fn *ir.Func) {
158 if !goexperiment.NewInliner {
161 captureFuncDumpEntry(fn, canInline, inlineMaxBudget)
164 ir.Visit(fn, func(n ir.Node) {
165 if clo, ok := n.(*ir.ClosureExpr); ok {
171 emitDumpToFile(dumpfile)
175 // emitDumpToFile writes out the buffer function property dump entries
176 // to a file, for unit testing. Dump entries need to be sorted by
177 // definition line, and due to generics we need to account for the
178 // possibility that several ir.Func's will have the same def line.
179 func emitDumpToFile(dumpfile string) {
180 mode := os.O_WRONLY | os.O_CREATE | os.O_TRUNC
181 if dumpfile[0] == '+' {
182 dumpfile = dumpfile[1:]
183 mode = os.O_WRONLY | os.O_APPEND | os.O_CREATE
185 if dumpfile[0] == '%' {
186 dumpfile = dumpfile[1:]
187 d, b := filepath.Dir(dumpfile), filepath.Base(dumpfile)
188 ptag := strings.ReplaceAll(types.LocalPkg.Path, "/", ":")
189 dumpfile = d + "/" + ptag + "." + b
191 outf, err := os.OpenFile(dumpfile, mode, 0644)
193 base.Fatalf("opening function props dump file %q: %v\n", dumpfile, err)
196 dumpFilePreamble(outf)
198 atline := map[uint]uint{}
199 sl := make([]fnInlHeur, 0, len(dumpBuffer))
200 for _, e := range dumpBuffer {
202 atline[e.line] = atline[e.line] + 1
204 sl = sortFnInlHeurSlice(sl)
207 for _, entry := range sl {
209 if prevline == entry.line {
212 prevline = entry.line
213 atl := atline[entry.line]
214 if err := dumpFnPreamble(outf, &entry, nil, idx, atl); err != nil {
215 base.Fatalf("function props dump: %v\n", err)
221 // captureFuncDumpEntry grabs the function properties object for 'fn'
222 // and enqueues it for later dumping. Used for the
223 // "-d=dumpinlfuncprops=..." command line flag, intended for use
224 // primarily in unit testing.
225 func captureFuncDumpEntry(fn *ir.Func, canInline func(*ir.Func), inlineMaxBudget int32) {
226 // avoid capturing compiler-generated equality funcs.
227 if strings.HasPrefix(fn.Sym().Name, ".eq.") {
231 // Props object should already be present, unless this is a
232 // directly recursive routine.
234 AnalyzeFunc(fn, canInline, inlineMaxBudget)
236 if fn.Inl != nil && fn.Inl.Properties == "" {
237 fn.Inl.Properties = fih.props.SerializeToString()
240 if dumpBuffer == nil {
241 dumpBuffer = make(map[*ir.Func]fnInlHeur)
243 if _, ok := dumpBuffer[fn]; ok {
244 // we can wind up seeing closures multiple times here,
245 // so don't add them more than once.
248 if debugTrace&debugTraceFuncs != 0 {
249 fmt.Fprintf(os.Stderr, "=-= capturing dump for %v:\n", fn)
254 // dumpFilePreamble writes out a file-level preamble for a given
255 // Go function as part of a function properties dump.
256 func dumpFilePreamble(w io.Writer) {
257 fmt.Fprintf(w, "// DO NOT EDIT (use 'go test -v -update-expected' instead.)\n")
258 fmt.Fprintf(w, "// See cmd/compile/internal/inline/inlheur/testdata/props/README.txt\n")
259 fmt.Fprintf(w, "// for more information on the format of this file.\n")
260 fmt.Fprintf(w, "// %s\n", preambleDelimiter)
263 // dumpFnPreamble writes out a function-level preamble for a given
264 // Go function as part of a function properties dump. See the
265 // README.txt file in testdata/props for more on the format of
267 func dumpFnPreamble(w io.Writer, fih *fnInlHeur, ecst encodedCallSiteTab, idx, atl uint) error {
268 fmt.Fprintf(w, "// %s %s %d %d %d\n",
269 fih.file, fih.fname, fih.line, idx, atl)
270 // emit props as comments, followed by delimiter
271 fmt.Fprintf(w, "%s// %s\n", fih.props.ToString("// "), comDelimiter)
272 data, err := json.Marshal(fih.props)
274 return fmt.Errorf("marshall error %v\n", err)
276 fmt.Fprintf(w, "// %s\n", string(data))
277 dumpCallSiteComments(w, fih.cstab, ecst)
278 fmt.Fprintf(w, "// %s\n", fnDelimiter)
282 // sortFnInlHeurSlice sorts a slice of fnInlHeur based on
283 // the starting line of the function definition, then by name.
284 func sortFnInlHeurSlice(sl []fnInlHeur) []fnInlHeur {
285 sort.SliceStable(sl, func(i, j int) bool {
286 if sl[i].line != sl[j].line {
287 return sl[i].line < sl[j].line
289 return sl[i].fname < sl[j].fname
294 // delimiters written to various preambles to make parsing of
296 const preambleDelimiter = "<endfilepreamble>"
297 const fnDelimiter = "<endfuncpreamble>"
298 const comDelimiter = "<endpropsdump>"
299 const csDelimiter = "<endcallsites>"
301 // dumpBuffer stores up function properties dumps when
302 // "-d=dumpinlfuncprops=..." is in effect.
303 var dumpBuffer map[*ir.Func]fnInlHeur