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

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>

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

diff --git a/test/escape5.go b/test/escape5.go
index 2ed2023cd26e72ad3db20eeebf28a6deaae3a363..82be2c38e790e64f8ffc62f86a84d8572e563142 100644 (file)
--- a/test/escape5.go
+++ b/test/escape5.go
@@ -269,3 +269,14 @@ func f28369(n int) int {
 
        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
+}