Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[release-branch.go1.24] cmd/compile: remove no-longer-necessary recursive inlining checks

Browse source 
this does result in a little bit more inlining,
cmd/compile text is 0.5% larger,
bent-benchmark text geomeans grow by only 0.02%.
some of our tests make assumptions about inlining.

Fixes: #73440.

Change-Id: I999d1798aca5dc64a1928bd434258a61e702951a
Reviewed-on: https://go-review.googlesource.com/c/go/+/655157
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/666555
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Carlos Amedee <carlos@golang.org>
This commit is contained in:
David Chase 2025-03-05 14:27:15 -05:00 • committed by Carlos Amedee
parent f66ab6521c
commit 06fd2f115b
9 changed files with 21 additions and 85 deletions
Download patch file Download diff file Expand all files Collapse all files

75
src/cmd/compile/internal/inline/inl.go
View file

@ -170,19 +170,8 @@ func CanInlineFuncs(funcs []*ir.Func, profile *pgoir.Profile) {
}
ir.VisitFuncsBottomUp(funcs, func(funcs []*ir.Func, recursive bool) {
numfns := numNonClosures(funcs)
for _, fn := range funcs {
if !recursive || numfns > 1 {
// We allow inlining if there is no
// recursion, or the recursion cycle is
// across more than one function.
CanInline(fn, profile)
} else {
if base.Flag.LowerM > 1 && fn.OClosure == nil {
fmt.Printf("%v: cannot inline %v: recursive\n", ir.Line(fn), fn.Nname)
}
}
CanInline(fn, profile)
if inlheur.Enabled() {
analyzeFuncProps(fn, profile)
}
@ -1023,68 +1012,6 @@ func canInlineCallExpr(callerfn *ir.Func, n *ir.CallExpr, callee *ir.Func, bigCa
}
}
if callee == callerfn {
// Can't recursively inline a function into itself.
if log && logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to %s", ir.FuncName(callerfn)))
}
return false, 0, false
}
isClosureParent := func(closure, parent *ir.Func) bool {
for p := closure.ClosureParent; p != nil; p = p.ClosureParent {
if p == parent {
return true
}
}
return false
}
if isClosureParent(callerfn, callee) {
// Can't recursively inline a parent of the closure into itself.
if log && logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to closure parent: %s, %s", ir.FuncName(callerfn), ir.FuncName(callee)))
}
return false, 0, false
}
if isClosureParent(callee, callerfn) {
// Can't recursively inline a closure if there's a call to the parent in closure body.
if ir.Any(callee, func(node ir.Node) bool {
if call, ok := node.(*ir.CallExpr); ok {
if name, ok := call.Fun.(*ir.Name); ok && isClosureParent(callerfn, name.Func) {
return true
}
}
return false
}) {
if log && logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to closure parent: %s, %s", ir.FuncName(callerfn), ir.FuncName(callee)))
}
return false, 0, false
}
}
do := func(fn *ir.Func) bool {
// Can't recursively inline a function if the function body contains
// a call to a function f, which the function f is one of the call arguments.
return ir.Any(fn, func(node ir.Node) bool {
if call, ok := node.(*ir.CallExpr); ok {
for _, arg := range call.Args {
if call.Fun == arg {
return true
}
}
}
return false
})
}
for _, fn := range []*ir.Func{callerfn, callee} {
if do(fn) {
if log && logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", fmt.Sprintf("recursive call to function: %s", ir.FuncName(fn)))
}
return false, 0, false
}
}
if base.Flag.Cfg.Instrumenting && types.IsNoInstrumentPkg(callee.Sym().Pkg) {
// Runtime package must not be instrumented.
// Instrument skips runtime package. However, some runtime code can be