cmd/compile: fold constant comparisions into SETxxmem ops.

Fixes #22198

Change-Id: I5cb91c73069af8b16a2580d28756efd58c84b690
Reviewed-on: https://go-review.googlesource.com/69990
Run-TryBot: Keith Randall <khr@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Matthew Dempsky <mdempsky@google.com>

diff --git a/src/cmd/compile/internal/ssa/gen/AMD64.rules b/src/cmd/compile/internal/ssa/gen/AMD64.rules
index 7f7fa35bfeb571e59e20b205f14c17255816395e..522d8f13cc03e57253d68dda04ac0a6475da339b 100644 (file)
--- a/src/cmd/compile/internal/ssa/gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/gen/AMD64.rules
@@ -1545,6 +1545,66 @@
 (SETAE (FlagGT_ULT)) -> (MOVLconst [0])
 (SETAE (FlagGT_UGT)) -> (MOVLconst [1])
 
+(SETEQmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETEQmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETEQmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETEQmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETEQmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+
+(SETNEmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETNEmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETNEmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETNEmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETNEmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+
+(SETLmem  [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETLmem  [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETLmem  [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETLmem  [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETLmem  [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+
+(SETLEmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETLEmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETLEmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETLEmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETLEmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+
+(SETGmem  [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETGmem  [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETGmem  [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETGmem  [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETGmem  [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+
+(SETGEmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETGEmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETGEmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETGEmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETGEmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+
+(SETBmem  [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETBmem  [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETBmem  [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETBmem  [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETBmem  [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+
+(SETBEmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETBEmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETBEmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETBEmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETBEmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+
+(SETAmem  [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETAmem  [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETAmem  [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETAmem  [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETAmem  [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+
+(SETAEmem [off] {sym} ptr x:(FlagEQ)     mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETAEmem [off] {sym} ptr x:(FlagLT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETAEmem [off] {sym} ptr x:(FlagLT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+(SETAEmem [off] {sym} ptr x:(FlagGT_ULT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+(SETAEmem [off] {sym} ptr x:(FlagGT_UGT) mem) -> (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+
 // Remove redundant *const ops
 (ADDQconst [0] x) -> x
 (ADDLconst [c] x) && int32(c)==0 -> x

diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 1bddf29338a105cb949c3428c501ee923d6c78a9..6fcc64710272607a60ea1e0f2efe426c6757271a 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -316,7 +316,7 @@ func rewriteValueAMD64(v *Value) bool {
        case OpAMD64SETEQ:
                return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v)
        case OpAMD64SETEQmem:
-               return rewriteValueAMD64_OpAMD64SETEQmem_0(v)
+               return rewriteValueAMD64_OpAMD64SETEQmem_0(v) || rewriteValueAMD64_OpAMD64SETEQmem_10(v)
        case OpAMD64SETG:
                return rewriteValueAMD64_OpAMD64SETG_0(v)
        case OpAMD64SETGE:
@@ -336,7 +336,7 @@ func rewriteValueAMD64(v *Value) bool {
        case OpAMD64SETNE:
                return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v)
        case OpAMD64SETNEmem:
-               return rewriteValueAMD64_OpAMD64SETNEmem_0(v)
+               return rewriteValueAMD64_OpAMD64SETNEmem_0(v) || rewriteValueAMD64_OpAMD64SETNEmem_10(v)
        case OpAMD64SHLL:
                return rewriteValueAMD64_OpAMD64SHLL_0(v)
        case OpAMD64SHLLconst:
@@ -35824,6 +35824,8 @@ func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool {
        return false
 }
 func rewriteValueAMD64_OpAMD64SETAEmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETAEmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETBEmem [off] {sym} ptr x mem)
@@ -35846,9 +35848,126 @@ func rewriteValueAMD64_OpAMD64SETAEmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETAEmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAEmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAEmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAEmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAEmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETAmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETAmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETBmem [off] {sym} ptr x mem)
@@ -35871,6 +35990,121 @@ func rewriteValueAMD64_OpAMD64SETAmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETAmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETAmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool {
@@ -36026,6 +36260,8 @@ func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool {
        return false
 }
 func rewriteValueAMD64_OpAMD64SETBEmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETBEmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETAEmem [off] {sym} ptr x mem)
@@ -36048,9 +36284,126 @@ func rewriteValueAMD64_OpAMD64SETBEmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETBEmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBEmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBEmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBEmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBEmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETBmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETBmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETAmem [off] {sym} ptr x mem)
@@ -36073,6 +36426,121 @@ func rewriteValueAMD64_OpAMD64SETBmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETBmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETBmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool {
@@ -36701,6 +37169,126 @@ func rewriteValueAMD64_OpAMD64SETEQmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETEQmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       return false
+}
+func rewriteValueAMD64_OpAMD64SETEQmem_10(v *Value) bool {
+       b := v.Block
+       _ = b
+       // match: (SETEQmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETEQmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETEQmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETEQmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool {
@@ -36856,6 +37444,8 @@ func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool {
        return false
 }
 func rewriteValueAMD64_OpAMD64SETGEmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETGEmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETLEmem [off] {sym} ptr x mem)
@@ -36878,9 +37468,126 @@ func rewriteValueAMD64_OpAMD64SETGEmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETGEmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGEmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGEmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGEmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGEmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETGmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETGmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETLmem [off] {sym} ptr x mem)
@@ -36903,6 +37610,121 @@ func rewriteValueAMD64_OpAMD64SETGmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETGmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETGmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool {
@@ -37058,6 +37880,8 @@ func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool {
        return false
 }
 func rewriteValueAMD64_OpAMD64SETLEmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETLEmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETGEmem [off] {sym} ptr x mem)
@@ -37080,9 +37904,126 @@ func rewriteValueAMD64_OpAMD64SETLEmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETLEmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLEmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLEmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLEmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLEmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETLmem_0(v *Value) bool {
+       b := v.Block
+       _ = b
        // match: (SETLmem [off] {sym} ptr (InvertFlags x) mem)
        // cond:
        // result: (SETGmem [off] {sym} ptr x mem)
@@ -37105,6 +38046,121 @@ func rewriteValueAMD64_OpAMD64SETLmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETLmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETLmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool {
@@ -37733,6 +38789,126 @@ func rewriteValueAMD64_OpAMD64SETNEmem_0(v *Value) bool {
                v.AddArg(mem)
                return true
        }
+       // match: (SETNEmem [off] {sym} ptr x:(FlagEQ) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [0]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagEQ {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 0
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       return false
+}
+func rewriteValueAMD64_OpAMD64SETNEmem_10(v *Value) bool {
+       b := v.Block
+       _ = b
+       // match: (SETNEmem [off] {sym} ptr x:(FlagLT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETNEmem [off] {sym} ptr x:(FlagLT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagLT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETNEmem [off] {sym} ptr x:(FlagGT_ULT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_ULT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
+       // match: (SETNEmem [off] {sym} ptr x:(FlagGT_UGT) mem)
+       // cond:
+       // result: (MOVBstore [off] {sym} ptr (MOVLconst <x.Type> [1]) mem)
+       for {
+               off := v.AuxInt
+               sym := v.Aux
+               _ = v.Args[2]
+               ptr := v.Args[0]
+               x := v.Args[1]
+               if x.Op != OpAMD64FlagGT_UGT {
+                       break
+               }
+               mem := v.Args[2]
+               v.reset(OpAMD64MOVBstore)
+               v.AuxInt = off
+               v.Aux = sym
+               v.AddArg(ptr)
+               v0 := b.NewValue0(v.Pos, OpAMD64MOVLconst, x.Type)
+               v0.AuxInt = 1
+               v.AddArg(v0)
+               v.AddArg(mem)
+               return true
+       }
        return false
 }
 func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool {

diff --git a/test/fixedbugs/issue22198.go b/test/fixedbugs/issue22198.go
new file mode 100644 (file)
index 0000000..c874c1c
--- /dev/null
+++ b/test/fixedbugs/issue22198.go
@@ -0,0 +1,18 @@
+// compile
+
+// Copyright 2017 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 issue22198
+
+func f(a *bool, b bool) {
+       if b {
+               return
+       }
+       c := '\n'
+       if b {
+               c = ' '
+       }
+       *a = c == '\n'
+}