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: enable more inlining for unified IR

Browse source 
The non-unified frontend had repeated issues with inlining and
generics (#49309, #51909, #52907), which led us to substantially
restrict inlining when shape types were present.

However, these issues are evidently not present in unified IR's
inliner, and the safety restrictions added for the non-unified
frontend can simply be disabled in unified mode.

Fixes #54497.

Change-Id: I8e6ac9f3393c588bfaf14c6452891b9640a9d1bd
Reviewed-on: https://go-review.googlesource.com/c/go/+/424775
Reviewed-by: Cuong Manh Le <cuong.manhle.vn@gmail.com>
Run-TryBot: Matthew Dempsky <mdempsky@google.com>
TryBot-Result: Gopher Robot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Keith Randall <khr@google.com>
This commit is contained in:
Matthew Dempsky 2022-08-18 05:20:16 -07:00
parent d6294e00f0
commit 52016be3f4
4 changed files with 56 additions and 32 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -722,44 +722,47 @@ func mkinlcall(n *ir.CallExpr, fn *ir.Func, maxCost int32, inlMap map[*ir.Func]b
return n
}
// Don't inline a function fn that has no shape parameters, but is passed at
// least one shape arg. This means we must be inlining a non-generic function
// fn that was passed into a generic function, and can be called with a shape
// arg because it matches an appropriate type parameters. But fn may include
// an interface conversion (that may be applied to a shape arg) that was not
// apparent when we first created the instantiation of the generic function.
// We can't handle this if we actually do the inlining, since we want to know
// all interface conversions immediately after stenciling. So, we avoid
// inlining in this case, see issue #49309. (1)
//
// See discussion on go.dev/cl/406475 for more background.
if !fn.Type().Params().HasShape() {
for _, arg := range n.Args {
if arg.Type().HasShape() {
// The non-unified frontend has issues with inlining and shape parameters.
if base.Debug.Unified == 0 {
// Don't inline a function fn that has no shape parameters, but is passed at
// least one shape arg. This means we must be inlining a non-generic function
// fn that was passed into a generic function, and can be called with a shape
// arg because it matches an appropriate type parameters. But fn may include
// an interface conversion (that may be applied to a shape arg) that was not
// apparent when we first created the instantiation of the generic function.
// We can't handle this if we actually do the inlining, since we want to know
// all interface conversions immediately after stenciling. So, we avoid
// inlining in this case, see issue #49309. (1)
//
// See discussion on go.dev/cl/406475 for more background.
if !fn.Type().Params().HasShape() {
for _, arg := range n.Args {
if arg.Type().HasShape() {
if logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
fmt.Sprintf("inlining function %v has no-shape params with shape args", ir.FuncName(fn)))
}
return n
}
}
} else {
// Don't inline a function fn that has shape parameters, but is passed no shape arg.
// See comments (1) above, and issue #51909.
inlineable := len(n.Args) == 0 // Function has shape in type, with no arguments can always be inlined.
for _, arg := range n.Args {
if arg.Type().HasShape() {
inlineable = true
break
}
}
if !inlineable {
if logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
fmt.Sprintf("inlining function %v has no-shape params with shape args", ir.FuncName(fn)))
fmt.Sprintf("inlining function %v has shape params with no-shape args", ir.FuncName(fn)))
}
return n
}
}
} else {
// Don't inline a function fn that has shape parameters, but is passed no shape arg.
// See comments (1) above, and issue #51909.
inlineable := len(n.Args) == 0 // Function has shape in type, with no arguments can always be inlined.
for _, arg := range n.Args {
if arg.Type().HasShape() {
inlineable = true
break
}
}
if !inlineable {
if logopt.Enabled() {
logopt.LogOpt(n.Pos(), "cannotInlineCall", "inline", ir.FuncName(ir.CurFunc),
fmt.Sprintf("inlining function %v has shape params with no-shape args", ir.FuncName(fn)))
}
return n
}
}
if base.Flag.Cfg.Instrumenting && types.IsRuntimePkg(fn.Sym().Pkg) {