[release-branch.go1.18] cmd/compile: only inline method wrapper if method don't conta...

CL 327871 changes methodWrapper to always perform inlining after global
escape analysis. However, inlining the method may reveal closures, which
require walking all function bodies to decide whether to capture free
variables by value or by ref.

To fix it, just not doing inline if the method contains any closures.

Fixes #54725

Change-Id: I4b0255b86257cc6fe7e5fafbc545cc5cff9113e1
Reviewed-on: https://go-review.googlesource.com/c/go/+/426334
Reviewed-by: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Run-TryBot: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Reviewed-by: Heschi Kreinick <heschi@google.com>
Reviewed-on: https://go-review.googlesource.com/c/go/+/426159

diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go
index aec7358c32263b37a0845c06bc599833156b5b78..4ee9830db38317ec6f3c8bc807ace8c24ed6a60b 100644 (file)
--- a/src/cmd/compile/internal/reflectdata/reflect.go
+++ b/src/cmd/compile/internal/reflectdata/reflect.go
@@ -1878,14 +1878,14 @@ func methodWrapper(rcvr *types.Type, method *types.Field, forItab bool) *obj.LSy
        // the TOC to the appropriate value for that module. But if it returns
        // directly to the wrapper's caller, nothing will reset it to the correct
        // value for that function.
+       var call *ir.CallExpr
        if !base.Flag.Cfg.Instrumenting && rcvr.IsPtr() && methodrcvr.IsPtr() && method.Embedded != 0 && !types.IsInterfaceMethod(method.Type) && !(base.Ctxt.Arch.Name == "ppc64le" && base.Ctxt.Flag_dynlink) && !generic {
-               call := ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
+               call = ir.NewCallExpr(base.Pos, ir.OCALL, dot, nil)
                call.Args = ir.ParamNames(tfn.Type())
                call.IsDDD = tfn.Type().IsVariadic()
                fn.Body.Append(ir.NewTailCallStmt(base.Pos, call))
        } else {
                fn.SetWrapper(true) // ignore frame for panic+recover matching
-               var call *ir.CallExpr
 
                if generic && dot.X != nthis {
                        // If there is embedding involved, then we should do the
@@ -1970,7 +1970,22 @@ func methodWrapper(rcvr *types.Type, method *types.Field, forItab bool) *obj.LSy
        typecheck.Stmts(fn.Body)
 
        if AfterGlobalEscapeAnalysis {
-               inline.InlineCalls(fn)
+               // Inlining the method may reveal closures, which require walking all function bodies
+               // to decide whether to capture free variables by value or by ref. So we only do inline
+               // if the method do not contain any closures, otherwise, the escape analysis may make
+               // dead variables resurrected, and causing liveness analysis confused, see issue #53702.
+               var canInline bool
+               switch x := call.X.(type) {
+               case *ir.Name:
+                       canInline = len(x.Func.Closures) == 0
+               case *ir.SelectorExpr:
+                       if x.Op() == ir.OMETHEXPR {
+                               canInline = x.FuncName().Func != nil && len(x.FuncName().Func.Closures) == 0
+                       }
+               }
+               if canInline {
+                       inline.InlineCalls(fn)
+               }
                escape.Batch([]*ir.Func{fn}, false)
        }
 

diff --git a/test/fixedbugs/issue53702.go b/test/fixedbugs/issue53702.go
new file mode 100644 (file)
index 0000000..0b251c2
--- /dev/null
+++ b/test/fixedbugs/issue53702.go
@@ -0,0 +1,39 @@
+// run
+
+// Copyright 2022 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package main
+
+type Elem struct{}
+
+func (*Elem) Wait(callback func()) {}
+
+type Base struct {
+       elem [8]*Elem
+}
+
+var g_val = 1
+
+func (s *Base) Do() *int {
+       resp := &g_val
+       for _, e := range s.elem {
+               e.Wait(func() {
+                       *resp = 0
+               })
+       }
+       return resp
+}
+
+type Sub struct {
+       *Base
+}
+
+func main() {
+       a := Sub{new(Base)}
+       resp := a.Do()
+       if resp != nil && *resp != 1 {
+               panic("FAIL")
+       }
+}