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

cmd/compile: deadcode unreferenced hidden closures during inlining

Browse source 
When a closure is inlined, it may contain other hidden closures, which
the inliner will duplicate, rendering the original nested closures as
unreachable. Because they are unreachable, they don't get processed in
escape analysis, meaning that go/defer statements don't get rewritten,
which can then in turn trigger errors in walk. This patch looks for
nested hidden closures and marks them as dead, so that they can be
skipped later on in the compilation flow.  NB: if during escape
analysis we rediscover a hidden closure (due to an explicit reference)
that was previously marked dead, revive it at that point.

Fixes #59404.

Change-Id: I76db1e9cf1ee38bd1147aeae823f916dbbbf081b
Reviewed-on: https://go-review.googlesource.com/c/go/+/482355
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Than McIntosh <thanm@google.com>
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Cherry Mui <cherryyz@google.com>
This commit is contained in:
Than McIntosh 2023-04-04 18:56:21 -04:00
parent d7d235c92f
commit f1caf1aa1c
3 changed files with 122 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -229,6 +229,19 @@ func InlineDecls(p *pgo.Profile, decls []ir.Node, doInline bool) {
}
})
// Rewalk post-inlining functions to check for closures that are
// still visible but were (over-agressively) marked as dead, and
// undo that marking here. See #59404 for more context.
ir.VisitFuncsBottomUp(decls, func(list []*ir.Func, recursive bool) {
for _, n := range list {
ir.Visit(n, func(node ir.Node) {
if clo, ok := node.(*ir.ClosureExpr); ok && clo.Func.IsHiddenClosure() {
clo.Func.SetIsDeadcodeClosure(false)
}
})
}
})
if p != nil {
pgoInlineEpilogue(p, decls)
}
@ -883,6 +896,30 @@ func inlnode(n ir.Node, maxCost int32, inlCalls *[]*ir.InlinedCallExpr, edit fun
}
if fn := inlCallee(call.X, profile); fn != nil && typecheck.HaveInlineBody(fn) {
n = mkinlcall(call, fn, maxCost, inlCalls, edit)
if fn.IsHiddenClosure() {
// Visit function to pick out any contained hidden
// closures to mark them as dead, since they will no
// longer be reachable (if we leave them live, they
// will get skipped during escape analysis, which
// could mean that go/defer statements don't get
// desugared, causing later problems in walk). See
// #59404 for more context. Note also that the code
// below can sometimes be too aggressive (marking a closure
// dead even though it was captured by a local var).
// In this case we'll undo the dead marking in a cleanup
// pass that happens at the end of InlineDecls.
var vis func(node ir.Node)
vis = func(node ir.Node) {
if clo, ok := node.(*ir.ClosureExpr); ok && clo.Func.IsHiddenClosure() && !clo.Func.IsDeadcodeClosure() {
if base.Flag.LowerM > 2 {
fmt.Printf("%v: closure %v marked as dead\n", ir.Line(clo.Func), clo.Func)
}
clo.Func.SetIsDeadcodeClosure(true)
ir.Visit(clo.Func, vis)
}
}
ir.Visit(fn, vis)
}
}
}