cmd/compile: do not assume TST and TEQ set V on arm

These replacement rules assume that TST and TEQ set V. But TST and
TEQ do not set V. This is a problem because instructions like LT are
actually checking for N!=V. But with TST and TEQ not setting V, LT
doesn't do anything meaningful. It's possible to construct trivial
miscompilations from this, such as:

    package main

    var x = [4]int32{-0x7fffffff, 0x7fffffff, 2, 4}

    func main() {
        if x[0] > x[1] {
            panic("fail 1")
        }
        if x[2]&x[3] < 0 {
            panic("fail 2") // Fails here
        }
    }

That first comparison sets V, via the CMP that subtracts the values
causing the overflow. Then the second comparison operation thinks that
it uses the result of TST, when it actually uses the V from CMP.

Before this fix:

    TST             R0, R1
    BLT             loc_6C164

After this fix:

    TST             R0, R1
    BMI             loc_6C164

The BMI instruction checks the N flag, which TST sets.  This commit
fixes the issue by using [LG][TE]noov instead of vanilla [LG][TE], and
also adds a test case for the direct issue.

Fixes #42876.

Change-Id: I13c62c88d18574247ad002b671b38d2d0b0fc6fa
Reviewed-on: https://go-review.googlesource.com/c/go/+/274026
Run-TryBot: Jason A. Donenfeld <Jason@zx2c4.com>
TryBot-Result: Go Bot <gobot@golang.org>
Reviewed-by: Cherry Zhang <cherryyz@google.com>
Trust: Jason A. Donenfeld <Jason@zx2c4.com>

diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules
index 946acd4ccca9437538ace259d8284bd900d9eaa0..6637c6cae4620151edd45fe977b153e9ea271e2f 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/ARM.rules
+++ b/src/cmd/compile/internal/ssa/gen/ARM.rules
@@ -1369,38 +1369,38 @@
 (LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 => (LEnoov (CMNshiftLLreg x y z) yes no)
 (LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 => (LEnoov (CMNshiftRLreg x y z) yes no)
 (LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 => (LEnoov (CMNshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (LT (TST x y) yes no)
-(LT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (LT (TSTconst [c] x) yes no)
-(LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (LT (TSTshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (LT (TSTshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (LT (TSTshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (LT (TSTshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (LT (TSTshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (LT (TSTshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (LE (TST x y) yes no)
-(LE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (LE (TSTconst [c] x) yes no)
-(LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (LE (TSTshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (LE (TSTshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (LE (TSTshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (LE (TSTshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (LE (TSTshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (LE (TSTshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (LT (TEQ x y) yes no)
-(LT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (LT (TEQconst [c] x) yes no)
-(LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (LT (TEQshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (LT (TEQshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (LT (TEQshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (LT (TEQshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (LT (TEQshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (LT (TEQshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (LE (TEQ x y) yes no)
-(LE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1  => (LE (TEQconst [c] x) yes no)
-(LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (LE (TEQshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (LE (TEQshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (LE (TEQshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (LE (TEQshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (LE (TEQshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (LE (TEQshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (LTnoov (TST x y) yes no)
+(LT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (LTnoov (TSTconst [c] x) yes no)
+(LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (LTnoov (TSTshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (LTnoov (TSTshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (LTnoov (TSTshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (LTnoov (TSTshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (LTnoov (TSTshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (LTnoov (TSTshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (LEnoov (TST x y) yes no)
+(LE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (LEnoov (TSTconst [c] x) yes no)
+(LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (LEnoov (TSTshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (LEnoov (TSTshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (LEnoov (TSTshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (LEnoov (TSTshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (LEnoov (TSTshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (LEnoov (TSTshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (LTnoov (TEQ x y) yes no)
+(LT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (LTnoov (TEQconst [c] x) yes no)
+(LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (LTnoov (TEQshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (LTnoov (TEQshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (LTnoov (TEQshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (LTnoov (TEQshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (LTnoov (TEQshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (LTnoov (TEQshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (LEnoov (TEQ x y) yes no)
+(LE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1  => (LEnoov (TEQconst [c] x) yes no)
+(LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (LEnoov (TEQshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (LEnoov (TEQshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (LEnoov (TEQshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (LEnoov (TEQshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (LEnoov (TEQshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (LEnoov (TEQshiftRAreg x y z) yes no)
 (GT (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 => (GTnoov (CMP x y) yes no)
 (GT (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 => (GTnoov (CMP a (MUL <x.Type> x y)) yes no)
 (GT (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 => (GTnoov (CMPconst [c] x) yes no)
@@ -1436,39 +1436,39 @@
 (GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 => (GEnoov (CMNshiftLLreg x y z) yes no)
 (GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 => (GEnoov (CMNshiftRLreg x y z) yes no)
 (GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 => (GEnoov (CMNshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (GT (TST x y) yes no)
 (GT (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 => (GTnoov (CMN a (MUL <x.Type> x y)) yes no)
-(GT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (GT (TSTconst [c] x) yes no)
-(GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (GT (TSTshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (GT (TSTshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (GT (TSTshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (GT (TSTshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (GT (TSTshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (GT (TSTshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (GE (TST x y) yes no)
-(GE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (GE (TSTconst [c] x) yes no)
-(GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (GE (TSTshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (GE (TSTshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (GE (TSTshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (GE (TSTshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (GE (TSTshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (GE (TSTshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (GT (TEQ x y) yes no)
-(GT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (GT (TEQconst [c] x) yes no)
-(GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (GT (TEQshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (GT (TEQshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (GT (TEQshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (GT (TEQshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (GT (TEQshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (GT (TEQshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (GE (TEQ x y) yes no)
-(GE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (GE (TEQconst [c] x) yes no)
-(GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (GE (TEQshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (GE (TEQshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (GE (TEQshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (GE (TEQshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (GE (TEQshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (GE (TEQshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (GTnoov (TST x y) yes no)
+(GT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (GTnoov (TSTconst [c] x) yes no)
+(GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (GTnoov (TSTshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (GTnoov (TSTshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (GTnoov (TSTshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (GTnoov (TSTshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (GTnoov (TSTshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (GTnoov (TSTshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 => (GEnoov (TST x y) yes no)
+(GE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 => (GEnoov (TSTconst [c] x) yes no)
+(GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 => (GEnoov (TSTshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 => (GEnoov (TSTshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 => (GEnoov (TSTshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 => (GEnoov (TSTshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 => (GEnoov (TSTshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 => (GEnoov (TSTshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (GTnoov (TEQ x y) yes no)
+(GT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (GTnoov (TEQconst [c] x) yes no)
+(GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (GTnoov (TEQshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (GTnoov (TEQshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (GTnoov (TEQshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (GTnoov (TEQshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (GTnoov (TEQshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (GTnoov (TEQshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 => (GEnoov (TEQ x y) yes no)
+(GE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 => (GEnoov (TEQconst [c] x) yes no)
+(GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 => (GEnoov (TEQshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 => (GEnoov (TEQshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 => (GEnoov (TEQshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 => (GEnoov (TEQshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 => (GEnoov (TEQshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 => (GEnoov (TEQshiftRAreg x y z) yes no)
 
 (MOVBUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVWconst [int32(read8(sym, int64(off)))])
 (MOVHUload [off] {sym} (SB) _) && symIsRO(sym) => (MOVWconst [int32(read16(sym, int64(off), config.ctxt.Arch.ByteOrder))])

diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 47fd0a94cce8c2f8e9e439d8b91e295c5003f085..68495c558c07d6875d677b2ad7a452b234f4c7a8 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -17389,7 +17389,7 @@ func rewriteBlockARM(b *Block) bool {
                }
                // match: (GE (CMPconst [0] l:(AND x y)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TST x y) yes no)
+               // result: (GEnoov (TST x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17410,14 +17410,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMGE, v0)
+                               b.resetWithControl(BlockARMGEnoov, v0)
                                return true
                        }
                        break
                }
                // match: (GE (CMPconst [0] l:(ANDconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTconst [c] x) yes no)
+               // result: (GEnoov (TSTconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17435,12 +17435,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftLL x y [c]) yes no)
+               // result: (GEnoov (TSTshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17459,12 +17459,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftRL x y [c]) yes no)
+               // result: (GEnoov (TSTshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17483,12 +17483,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftRA x y [c]) yes no)
+               // result: (GEnoov (TSTshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17507,12 +17507,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftLLreg x y z) yes no)
+               // result: (GEnoov (TSTshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17530,12 +17530,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftRLreg x y z) yes no)
+               // result: (GEnoov (TSTshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17553,12 +17553,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TSTshiftRAreg x y z) yes no)
+               // result: (GEnoov (TSTshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17576,12 +17576,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XOR x y)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQ x y) yes no)
+               // result: (GEnoov (TEQ x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17602,14 +17602,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMGE, v0)
+                               b.resetWithControl(BlockARMGEnoov, v0)
                                return true
                        }
                        break
                }
                // match: (GE (CMPconst [0] l:(XORconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQconst [c] x) yes no)
+               // result: (GEnoov (TEQconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17627,12 +17627,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftLL x y [c]) yes no)
+               // result: (GEnoov (TEQshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17651,12 +17651,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftRL x y [c]) yes no)
+               // result: (GEnoov (TEQshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17675,12 +17675,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftRA x y [c]) yes no)
+               // result: (GEnoov (TEQshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17699,12 +17699,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftLLreg x y z) yes no)
+               // result: (GEnoov (TEQshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17722,12 +17722,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftRLreg x y z) yes no)
+               // result: (GEnoov (TEQshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17745,12 +17745,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
                // match: (GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GE (TEQshiftRAreg x y z) yes no)
+               // result: (GEnoov (TEQshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -17768,7 +17768,7 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGE, v0)
+                       b.resetWithControl(BlockARMGEnoov, v0)
                        return true
                }
        case BlockARMGEnoov:
@@ -18278,9 +18278,34 @@ func rewriteBlockARM(b *Block) bool {
                        b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
+               // match: (GT (CMPconst [0] l:(MULA x y a)) yes no)
+               // cond: l.Uses==1
+               // result: (GTnoov (CMN a (MUL <x.Type> x y)) yes no)
+               for b.Controls[0].Op == OpARMCMPconst {
+                       v_0 := b.Controls[0]
+                       if auxIntToInt32(v_0.AuxInt) != 0 {
+                               break
+                       }
+                       l := v_0.Args[0]
+                       if l.Op != OpARMMULA {
+                               break
+                       }
+                       a := l.Args[2]
+                       x := l.Args[0]
+                       y := l.Args[1]
+                       if !(l.Uses == 1) {
+                               break
+                       }
+                       v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
+                       v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
+                       v1.AddArg2(x, y)
+                       v0.AddArg2(a, v1)
+                       b.resetWithControl(BlockARMGTnoov, v0)
+                       return true
+               }
                // match: (GT (CMPconst [0] l:(AND x y)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TST x y) yes no)
+               // result: (GTnoov (TST x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18301,39 +18326,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMGT, v0)
+                               b.resetWithControl(BlockARMGTnoov, v0)
                                return true
                        }
                        break
                }
-               // match: (GT (CMPconst [0] l:(MULA x y a)) yes no)
-               // cond: l.Uses==1
-               // result: (GTnoov (CMN a (MUL <x.Type> x y)) yes no)
-               for b.Controls[0].Op == OpARMCMPconst {
-                       v_0 := b.Controls[0]
-                       if auxIntToInt32(v_0.AuxInt) != 0 {
-                               break
-                       }
-                       l := v_0.Args[0]
-                       if l.Op != OpARMMULA {
-                               break
-                       }
-                       a := l.Args[2]
-                       x := l.Args[0]
-                       y := l.Args[1]
-                       if !(l.Uses == 1) {
-                               break
-                       }
-                       v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
-                       v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
-                       v1.AddArg2(x, y)
-                       v0.AddArg2(a, v1)
-                       b.resetWithControl(BlockARMGTnoov, v0)
-                       return true
-               }
                // match: (GT (CMPconst [0] l:(ANDconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTconst [c] x) yes no)
+               // result: (GTnoov (TSTconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18351,12 +18351,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftLL x y [c]) yes no)
+               // result: (GTnoov (TSTshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18375,12 +18375,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftRL x y [c]) yes no)
+               // result: (GTnoov (TSTshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18399,12 +18399,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftRA x y [c]) yes no)
+               // result: (GTnoov (TSTshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18423,12 +18423,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftLLreg x y z) yes no)
+               // result: (GTnoov (TSTshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18446,12 +18446,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftRLreg x y z) yes no)
+               // result: (GTnoov (TSTshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18469,12 +18469,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TSTshiftRAreg x y z) yes no)
+               // result: (GTnoov (TSTshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18492,12 +18492,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XOR x y)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQ x y) yes no)
+               // result: (GTnoov (TEQ x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18518,14 +18518,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMGT, v0)
+                               b.resetWithControl(BlockARMGTnoov, v0)
                                return true
                        }
                        break
                }
                // match: (GT (CMPconst [0] l:(XORconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQconst [c] x) yes no)
+               // result: (GTnoov (TEQconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18543,12 +18543,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftLL x y [c]) yes no)
+               // result: (GTnoov (TEQshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18567,12 +18567,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftRL x y [c]) yes no)
+               // result: (GTnoov (TEQshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18591,12 +18591,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftRA x y [c]) yes no)
+               // result: (GTnoov (TEQshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18615,12 +18615,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftLLreg x y z) yes no)
+               // result: (GTnoov (TEQshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18638,12 +18638,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftRLreg x y z) yes no)
+               // result: (GTnoov (TEQshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18661,12 +18661,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
                // match: (GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (GT (TEQshiftRAreg x y z) yes no)
+               // result: (GTnoov (TEQshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -18684,7 +18684,7 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMGT, v0)
+                       b.resetWithControl(BlockARMGTnoov, v0)
                        return true
                }
        case BlockARMGTnoov:
@@ -19312,7 +19312,7 @@ func rewriteBlockARM(b *Block) bool {
                }
                // match: (LE (CMPconst [0] l:(AND x y)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TST x y) yes no)
+               // result: (LEnoov (TST x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19333,14 +19333,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMLE, v0)
+                               b.resetWithControl(BlockARMLEnoov, v0)
                                return true
                        }
                        break
                }
                // match: (LE (CMPconst [0] l:(ANDconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTconst [c] x) yes no)
+               // result: (LEnoov (TSTconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19358,12 +19358,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftLL x y [c]) yes no)
+               // result: (LEnoov (TSTshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19382,12 +19382,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftRL x y [c]) yes no)
+               // result: (LEnoov (TSTshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19406,12 +19406,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftRA x y [c]) yes no)
+               // result: (LEnoov (TSTshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19430,12 +19430,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftLLreg x y z) yes no)
+               // result: (LEnoov (TSTshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19453,12 +19453,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftRLreg x y z) yes no)
+               // result: (LEnoov (TSTshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19476,12 +19476,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TSTshiftRAreg x y z) yes no)
+               // result: (LEnoov (TSTshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19499,12 +19499,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XOR x y)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQ x y) yes no)
+               // result: (LEnoov (TEQ x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19525,14 +19525,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMLE, v0)
+                               b.resetWithControl(BlockARMLEnoov, v0)
                                return true
                        }
                        break
                }
                // match: (LE (CMPconst [0] l:(XORconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQconst [c] x) yes no)
+               // result: (LEnoov (TEQconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19550,12 +19550,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftLL x y [c]) yes no)
+               // result: (LEnoov (TEQshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19574,12 +19574,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftRL x y [c]) yes no)
+               // result: (LEnoov (TEQshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19598,12 +19598,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftRA x y [c]) yes no)
+               // result: (LEnoov (TEQshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19622,12 +19622,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftLLreg x y z) yes no)
+               // result: (LEnoov (TEQshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19645,12 +19645,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftRLreg x y z) yes no)
+               // result: (LEnoov (TEQshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19668,12 +19668,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
                // match: (LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LE (TEQshiftRAreg x y z) yes no)
+               // result: (LEnoov (TEQshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -19691,7 +19691,7 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLE, v0)
+                       b.resetWithControl(BlockARMLEnoov, v0)
                        return true
                }
        case BlockARMLEnoov:
@@ -20228,7 +20228,7 @@ func rewriteBlockARM(b *Block) bool {
                }
                // match: (LT (CMPconst [0] l:(AND x y)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TST x y) yes no)
+               // result: (LTnoov (TST x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20249,14 +20249,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMLT, v0)
+                               b.resetWithControl(BlockARMLTnoov, v0)
                                return true
                        }
                        break
                }
                // match: (LT (CMPconst [0] l:(ANDconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTconst [c] x) yes no)
+               // result: (LTnoov (TSTconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20274,12 +20274,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftLL x y [c]) yes no)
+               // result: (LTnoov (TSTshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20298,12 +20298,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftRL x y [c]) yes no)
+               // result: (LTnoov (TSTshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20322,12 +20322,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftRA x y [c]) yes no)
+               // result: (LTnoov (TSTshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20346,12 +20346,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftLLreg x y z) yes no)
+               // result: (LTnoov (TSTshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20369,12 +20369,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftRLreg x y z) yes no)
+               // result: (LTnoov (TSTshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20392,12 +20392,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TSTshiftRAreg x y z) yes no)
+               // result: (LTnoov (TSTshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20415,12 +20415,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XOR x y)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQ x y) yes no)
+               // result: (LTnoov (TEQ x y) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20441,14 +20441,14 @@ func rewriteBlockARM(b *Block) bool {
                                }
                                v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
                                v0.AddArg2(x, y)
-                               b.resetWithControl(BlockARMLT, v0)
+                               b.resetWithControl(BlockARMLTnoov, v0)
                                return true
                        }
                        break
                }
                // match: (LT (CMPconst [0] l:(XORconst [c] x)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQconst [c] x) yes no)
+               // result: (LTnoov (TEQconst [c] x) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20466,12 +20466,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg(x)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftLL x y [c]) yes no)
+               // result: (LTnoov (TEQshiftLL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20490,12 +20490,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftRL x y [c]) yes no)
+               // result: (LTnoov (TEQshiftRL x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20514,12 +20514,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftRA x y [c]) yes no)
+               // result: (LTnoov (TEQshiftRA x y [c]) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20538,12 +20538,12 @@ func rewriteBlockARM(b *Block) bool {
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
                        v0.AuxInt = int32ToAuxInt(c)
                        v0.AddArg2(x, y)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftLLreg x y z) yes no)
+               // result: (LTnoov (TEQshiftLLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20561,12 +20561,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftRLreg x y z) yes no)
+               // result: (LTnoov (TEQshiftRLreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20584,12 +20584,12 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
                // match: (LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
                // cond: l.Uses==1
-               // result: (LT (TEQshiftRAreg x y z) yes no)
+               // result: (LTnoov (TEQshiftRAreg x y z) yes no)
                for b.Controls[0].Op == OpARMCMPconst {
                        v_0 := b.Controls[0]
                        if auxIntToInt32(v_0.AuxInt) != 0 {
@@ -20607,7 +20607,7 @@ func rewriteBlockARM(b *Block) bool {
                        }
                        v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
                        v0.AddArg3(x, y, z)
-                       b.resetWithControl(BlockARMLT, v0)
+                       b.resetWithControl(BlockARMLTnoov, v0)
                        return true
                }
        case BlockARMLTnoov:

diff --git a/test/fixedbugs/issue42876.go b/test/fixedbugs/issue42876.go
new file mode 100644 (file)
index 0000000..67cf491
--- /dev/null
+++ b/test/fixedbugs/issue42876.go
@@ -0,0 +1,18 @@
+// run
+
+// Copyright 2020 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
+
+var x = [4]int32{-0x7fffffff, 0x7fffffff, 2, 4}
+
+func main() {
+       if x[0] > x[1] {
+               panic("fail 1")
+       }
+       if x[2]&x[3] < 0 {
+               panic("fail 2") // Fails here
+       }
+}