qbit/go
1
0
Fork 0
mirror of https://github.com/golang/go synced 2024-11-22 22:30:02 -07:00
Code Releases Activity

cmd/compile: fix escape analysis of heap-allocated results

Browse Source 
One of escape analysis's responsibilities is to summarize whether/how
each function parameter flows to the heap so we can correctly
incorporate those flows into callers' escape analysis data flow
graphs.

As an optimization, we separately record when parameters flow to
result parameters, so that we can more precisely analyze parameter
flows based on how the results are used at the call site. However, if
a named result parameter itself needs to be heap allocated, this
optimization isn't safe and the parameter needs to be recorded as
flowing to heap rather than flowing to result.

Escape analysis used to get this correct because it conservatively
rewalked the data-flow graph multiple times. So even though it would
incorrectly record the result parameter flow, it would separately find
a flow to the heap. However, CL 196811 (specifically, case 3)
optimized the walking logic to reduce unnecessary rewalks causing us
to stop finding the extra heap flow.

This CL fixes the issue by correcting location.leakTo to be sensitive
to sink.escapes and not record result-flows when the result parameter
escapes to the heap.

Fixes #44614.

Change-Id: I48742ed35a6cab591094e2d23a439e205bd65c50
Reviewed-on: https://go-review.googlesource.com/c/go/+/297289
Trust: Matthew Dempsky <mdempsky@google.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
Matthew Dempsky 2021-02-27 09:41:19 -08:00
parent 998fe70b68
commit a429926159
2 changed files with 15 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

7
src/cmd/compile/internal/escape/escape.go
View File

@ -1625,9 +1625,10 @@ func containsClosure(f, c *ir.Func) bool {
// leak records that parameter l leaks to sink. // leak records that parameter l leaks to sink.
func (l *location) leakTo(sink *location, derefs int) { func (l *location) leakTo(sink *location, derefs int) {
// If sink is a result parameter and we can fit return bits // If sink is a result parameter that doesn't escape (#44614)
// into the escape analysis tag, then record a return leak. // and we can fit return bits into the escape analysis tag,
if sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn { // then record as a result leak.
if !sink.escapes && sink.isName(ir.PPARAMOUT) && sink.curfn == l.curfn {
ri := sink.resultIndex - 1 ri := sink.resultIndex - 1
if ri < numEscResults { if ri < numEscResults {
// Leak to result parameter. // Leak to result parameter.

11
test/escape5.go
View File

@ -269,3 +269,14 @@ func f28369(n int) int {
return 1 + f28369(n-1) return 1 + f28369(n-1)
} }
// Issue 44614: parameters that flow to a heap-allocated result
// parameter must be recorded as a heap-flow rather than a
// result-flow.
// N.B., must match "leaking param: p",
// but *not* "leaking param: p to result r level=0".
func f(p *int) (r *int) { // ERROR "leaking param: p$" "moved to heap: r"
sink4 = &r
return p
}