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: remove 68857 min & max flowLimit workaround in prove

Browse source 
We can know this is correct because all the testcases added by CL 656157 are still passing.
Partial revert of CL 656157 (everything but the testcases).

Change-Id: I24931fa1affba7e9e92233b3de74ebade3d48a09
Reviewed-on: https://go-review.googlesource.com/c/go/+/714921
Auto-Submit: Jorropo <jorropo.pgm@gmail.com>
Reviewed-by: Keith Randall <khr@google.com>
Reviewed-by: Michael Knyszek <mknyszek@google.com>
Reviewed-by: Keith Randall <khr@golang.org>
LUCI-TryBot-Result: Go LUCI <golang-scoped@luci-project-accounts.iam.gserviceaccount.com>
This commit is contained in:
Jorropo 2025-10-25 15:34:02 +02:00 • committed by Gopher Robot
parent 53be78630a
commit a50de4bda7
1 changed files with 0 additions and 83 deletions
Download patch file Download diff file Expand all files Collapse all files

83
src/cmd/compile/internal/ssa/prove.go
View file

@ -1996,89 +1996,6 @@ func (ft *factsTable) flowLimit(v *Value) bool {
return ft.newLimit(v, lim) return ft.newLimit(v, lim)
case OpPhi: case OpPhi:
{
// Work around for go.dev/issue/68857, look for min(x, y) and max(x, y).
b := v.Block
if len(b.Preds) != 2 {
goto notMinNorMax
}
// FIXME: this code searches for the following losange pattern
// because that what ssagen produce for min and max builtins:
// conditionBlock → (firstBlock, secondBlock) → v.Block
// there are three non losange equivalent constructions
// we could match for, but I didn't bother:
// conditionBlock → (v.Block, secondBlock → v.Block)
// conditionBlock → (firstBlock → v.Block, v.Block)
// conditionBlock → (v.Block, v.Block)
firstBlock, secondBlock := b.Preds[0].b, b.Preds[1].b
if firstBlock.Kind != BlockPlain || secondBlock.Kind != BlockPlain {
goto notMinNorMax
}
if len(firstBlock.Preds) != 1 || len(secondBlock.Preds) != 1 {
goto notMinNorMax
}
conditionBlock := firstBlock.Preds[0].b
if conditionBlock != secondBlock.Preds[0].b {
goto notMinNorMax
}
if conditionBlock.Kind != BlockIf {
goto notMinNorMax
}
less := conditionBlock.Controls[0]
var unsigned bool
switch less.Op {
case OpLess64U, OpLess32U, OpLess16U, OpLess8U,
OpLeq64U, OpLeq32U, OpLeq16U, OpLeq8U:
unsigned = true
case OpLess64, OpLess32, OpLess16, OpLess8,
OpLeq64, OpLeq32, OpLeq16, OpLeq8:
default:
goto notMinNorMax
}
small, big := less.Args[0], less.Args[1]
truev, falsev := v.Args[0], v.Args[1]
if conditionBlock.Succs[0].b == secondBlock {
truev, falsev = falsev, truev
}
bigl, smalll := ft.limits[big.ID], ft.limits[small.ID]
if truev == big {
if falsev == small {
// v := big if small <¿=? big else small
if unsigned {
maximum := max(bigl.umax, smalll.umax)
minimum := max(bigl.umin, smalll.umin)
return ft.unsignedMinMax(v, minimum, maximum)
} else {
maximum := max(bigl.max, smalll.max)
minimum := max(bigl.min, smalll.min)
return ft.signedMinMax(v, minimum, maximum)
}
} else {
goto notMinNorMax
}
} else if truev == small {
if falsev == big {
// v := small if small <¿=? big else big
if unsigned {
maximum := min(bigl.umax, smalll.umax)
minimum := min(bigl.umin, smalll.umin)
return ft.unsignedMinMax(v, minimum, maximum)
} else {
maximum := min(bigl.max, smalll.max)
minimum := min(bigl.min, smalll.min)
return ft.signedMinMax(v, minimum, maximum)
}
} else {
goto notMinNorMax
}
} else {
goto notMinNorMax
}
}
notMinNorMax:
// Compute the union of all the input phis. // Compute the union of all the input phis.
// Often this will convey no information, because the block // Often this will convey no information, because the block
// is not dominated by its predecessors and hence the // is not dominated by its predecessors and hence the