From d2d59299a29a93abfc88917c0995f7bc04ced9d5 Mon Sep 17 00:00:00 2001 From: Cuong Manh Le Date: Mon, 29 Aug 2022 10:48:28 +0700 Subject: [release-branch.go1.18] cmd/compile: only inline method wrapper if method don't contain closures 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 TryBot-Result: Gopher Robot Run-TryBot: Cuong Manh Le Reviewed-by: Heschi Kreinick Reviewed-on: https://go-review.googlesource.com/c/go/+/426159 --- src/cmd/compile/internal/reflectdata/reflect.go | 21 +++++++++++-- test/fixedbugs/issue53702.go | 39 +++++++++++++++++++++++++ 2 files changed, 57 insertions(+), 3 deletions(-) create mode 100644 test/fixedbugs/issue53702.go diff --git a/src/cmd/compile/internal/reflectdata/reflect.go b/src/cmd/compile/internal/reflectdata/reflect.go index aec7358c32..4ee9830db3 100644 --- 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 index 0000000000..0b251c2d7b --- /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") + } +} -- cgit v1.2.1