cmd/compile: on AMD64, turn x < 128 into x <= 127

author Jakub Ciolek <jakub@ciolek.dev>

Fri, 3 Jan 2025 12:52:11 +0000 (13:52 +0100)

committer Keith Randall <khr@golang.org>

Sun, 16 Feb 2025 15:23:13 +0000 (07:23 -0800)
author Jakub Ciolek <jakub@ciolek.dev>
Fri, 3 Jan 2025 12:52:11 +0000 (13:52 +0100)
committer Keith Randall <khr@golang.org>
Sun, 16 Feb 2025 15:23:13 +0000 (07:23 -0800)
diff --git a/src/cmd/compile/internal/ssa/_gen/AMD64.rules b/src/cmd/compile/internal/ssa/_gen/AMD64.rules

index 9177067e522206d4594f664eb6aed283d87a8b16..e590b41d5f5a2d7eff0a87ada2954ca8bf022f69 100644 (file)
--- a/src/cmd/compile/internal/ssa/_gen/AMD64.rules
+++ b/src/cmd/compile/internal/ssa/_gen/AMD64.rules
@@ -628,6 +628,21 @@
  // x & 1 == 0 -> (x & 1) ^ 1
  (SETAE (BT(L|Q)const [0] x)) => (XORLconst [1] (ANDLconst <typ.Bool> [1] x))
  
+// Shorten compare by rewriting x < 128 as x <= 127, which can be encoded in a single-byte immediate on x86.
+(SETL c:(CMP(Q|L)const [128] x)) && c.Uses == 1 => (SETLE (CMP(Q|L)const [127] x))
+(SETB c:(CMP(Q|L)const [128] x)) && c.Uses == 1 => (SETBE (CMP(Q|L)const [127] x))
+
+// x >= 128 -> x > 127
+(SETGE c:(CMP(Q|L)const [128] x)) && c.Uses == 1 => (SETG (CMP(Q|L)const [127] x))
+(SETAE c:(CMP(Q|L)const [128] x)) && c.Uses == 1 => (SETA (CMP(Q|L)const [127] x))
+
+(CMOVQLT x y c:(CMP(Q|L)const [128] z)) && c.Uses == 1 => (CMOVQLE x y (CMP(Q|L)const [127] z))
+(CMOVLLT x y c:(CMP(Q|L)const [128] z)) && c.Uses == 1 => (CMOVLLE x y (CMP(Q|L)const [127] z))
+(LT          c:(CMP(Q|L)const [128] z) yes no) && c.Uses == 1 => (LE (CMP(Q|L)const [127] z) yes no)
+(CMOVQGE x y c:(CMP(Q|L)const [128] z)) && c.Uses == 1 => (CMOVQGT x y (CMP(Q|L)const [127] z))
+(CMOVLGE x y c:(CMP(Q|L)const [128] z)) && c.Uses == 1 => (CMOVLGT x y (CMP(Q|L)const [127] z))
+(GE          c:(CMP(Q|L)const [128] z) yes no) && c.Uses == 1 => (GT (CMP(Q|L)const [127] z)  yes no)
+
  // Recognize bit tests: a&(1<<b) != 0 for b suitably bounded
  // Note that BTx instructions use the carry bit, so we need to convert tests for zero flag
  // into tests for carry flags.
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go

index 63376dcb76f2d98668d8e4ad9aa3ac3ff75d08b1..be9b3d9ea98d3804dd2f0e0ce1e804adce13f4d6 100644 (file)
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -4246,6 +4246,7 @@ func rewriteValueAMD64_OpAMD64CMOVLGE(v *Value) bool {
         v_2 := v.Args[2]
         v_1 := v.Args[1]
         v_0 := v.Args[0]
+       b := v.Block
         // match: (CMOVLGE x y (InvertFlags cond))
         // result: (CMOVLLE x y cond)
         for {
@@ -4309,6 +4310,48 @@ func rewriteValueAMD64_OpAMD64CMOVLGE(v *Value) bool {
                 v.copyOf(y)
                 return true
         }
+       // match: (CMOVLGE x y c:(CMPQconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVLGT x y (CMPQconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVLGT)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
+       // match: (CMOVLGE x y c:(CMPLconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVLGT x y (CMPLconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVLGT)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
         return false
  }
  func rewriteValueAMD64_OpAMD64CMOVLGT(v *Value) bool {
@@ -4591,6 +4634,7 @@ func rewriteValueAMD64_OpAMD64CMOVLLT(v *Value) bool {
         v_2 := v.Args[2]
         v_1 := v.Args[1]
         v_0 := v.Args[0]
+       b := v.Block
         // match: (CMOVLLT x y (InvertFlags cond))
         // result: (CMOVLGT x y cond)
         for {
@@ -4654,6 +4698,48 @@ func rewriteValueAMD64_OpAMD64CMOVLLT(v *Value) bool {
                 v.copyOf(x)
                 return true
         }
+       // match: (CMOVLLT x y c:(CMPQconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVLLE x y (CMPQconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVLLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
+       // match: (CMOVLLT x y c:(CMPLconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVLLE x y (CMPLconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVLLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
         return false
  }
  func rewriteValueAMD64_OpAMD64CMOVLNE(v *Value) bool {
@@ -5096,6 +5182,7 @@ func rewriteValueAMD64_OpAMD64CMOVQGE(v *Value) bool {
         v_2 := v.Args[2]
         v_1 := v.Args[1]
         v_0 := v.Args[0]
+       b := v.Block
         // match: (CMOVQGE x y (InvertFlags cond))
         // result: (CMOVQLE x y cond)
         for {
@@ -5159,6 +5246,48 @@ func rewriteValueAMD64_OpAMD64CMOVQGE(v *Value) bool {
                 v.copyOf(y)
                 return true
         }
+       // match: (CMOVQGE x y c:(CMPQconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVQGT x y (CMPQconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVQGT)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
+       // match: (CMOVQGE x y c:(CMPLconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVQGT x y (CMPLconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVQGT)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
         return false
  }
  func rewriteValueAMD64_OpAMD64CMOVQGT(v *Value) bool {
@@ -5441,6 +5570,7 @@ func rewriteValueAMD64_OpAMD64CMOVQLT(v *Value) bool {
         v_2 := v.Args[2]
         v_1 := v.Args[1]
         v_0 := v.Args[0]
+       b := v.Block
         // match: (CMOVQLT x y (InvertFlags cond))
         // result: (CMOVQGT x y cond)
         for {
@@ -5504,6 +5634,48 @@ func rewriteValueAMD64_OpAMD64CMOVQLT(v *Value) bool {
                 v.copyOf(x)
                 return true
         }
+       // match: (CMOVQLT x y c:(CMPQconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVQLE x y (CMPQconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVQLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
+       // match: (CMOVQLT x y c:(CMPLconst [128] z))
+       // cond: c.Uses == 1
+       // result: (CMOVQLE x y (CMPLconst [127] z))
+       for {
+               x := v_0
+               y := v_1
+               c := v_2
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               z := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64CMOVQLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(z)
+               v.AddArg3(x, y, v0)
+               return true
+       }
         return false
  }
  func rewriteValueAMD64_OpAMD64CMOVQNE(v *Value) bool {
@@ -16789,6 +16961,44 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool {
                 v.AddArg(v0)
                 return true
         }
+       // match: (SETAE c:(CMPQconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETA (CMPQconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETA)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
+       // match: (SETAE c:(CMPLconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETA (CMPLconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETA)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
         // match: (SETAE (InvertFlags x))
         // result: (SETBE x)
         for {
@@ -17174,6 +17384,7 @@ func rewriteValueAMD64_OpAMD64SETAstore(v *Value) bool {
  }
  func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
         v_0 := v.Args[0]
+       b := v.Block
         // match: (SETB (TESTQ x x))
         // result: (ConstBool [false])
         for {
@@ -17254,6 +17465,44 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
                 v.AddArg(x)
                 return true
         }
+       // match: (SETB c:(CMPQconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETBE (CMPQconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETBE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
+       // match: (SETB c:(CMPLconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETBE (CMPLconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETBE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
         // match: (SETB (InvertFlags x))
         // result: (SETA x)
         for {
@@ -18813,6 +19062,45 @@ func rewriteValueAMD64_OpAMD64SETG(v *Value) bool {
  }
  func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool {
         v_0 := v.Args[0]
+       b := v.Block
+       // match: (SETGE c:(CMPQconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETG (CMPQconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETG)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
+       // match: (SETGE c:(CMPLconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETG (CMPLconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETG)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
         // match: (SETGE (InvertFlags x))
         // result: (SETLE x)
         for {
@@ -19198,6 +19486,45 @@ func rewriteValueAMD64_OpAMD64SETGstore(v *Value) bool {
  }
  func rewriteValueAMD64_OpAMD64SETL(v *Value) bool {
         v_0 := v.Args[0]
+       b := v.Block
+       // match: (SETL c:(CMPQconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETLE (CMPQconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPQconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPQconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
+       // match: (SETL c:(CMPLconst [128] x))
+       // cond: c.Uses == 1
+       // result: (SETLE (CMPLconst [127] x))
+       for {
+               c := v_0
+               if c.Op != OpAMD64CMPLconst || auxIntToInt32(c.AuxInt) != 128 {
+                       break
+               }
+               x := c.Args[0]
+               if !(c.Uses == 1) {
+                       break
+               }
+               v.reset(OpAMD64SETLE)
+               v0 := b.NewValue0(v.Pos, OpAMD64CMPLconst, types.TypeFlags)
+               v0.AuxInt = int32ToAuxInt(127)
+               v0.AddArg(x)
+               v.AddArg(v0)
+               return true
+       }
         // match: (SETL (InvertFlags x))
         // result: (SETG x)
         for {
@@ -31015,6 +31342,42 @@ func rewriteBlockAMD64(b *Block) bool {
                         break
                 }
         case BlockAMD64GE:
+               // match: (GE c:(CMPQconst [128] z) yes no)
+               // cond: c.Uses == 1
+               // result: (GT (CMPQconst [127] z) yes no)
+               for b.Controls[0].Op == OpAMD64CMPQconst {
+                       c := b.Controls[0]
+                       if auxIntToInt32(c.AuxInt) != 128 {
+                               break
+                       }
+                       z := c.Args[0]
+                       if !(c.Uses == 1) {
+                               break
+                       }
+                       v0 := b.NewValue0(c.Pos, OpAMD64CMPQconst, types.TypeFlags)
+                       v0.AuxInt = int32ToAuxInt(127)
+                       v0.AddArg(z)
+                       b.resetWithControl(BlockAMD64GT, v0)
+                       return true
+               }
+               // match: (GE c:(CMPLconst [128] z) yes no)
+               // cond: c.Uses == 1
+               // result: (GT (CMPLconst [127] z) yes no)
+               for b.Controls[0].Op == OpAMD64CMPLconst {
+                       c := b.Controls[0]
+                       if auxIntToInt32(c.AuxInt) != 128 {
+                               break
+                       }
+                       z := c.Args[0]
+                       if !(c.Uses == 1) {
+                               break
+                       }
+                       v0 := b.NewValue0(c.Pos, OpAMD64CMPLconst, types.TypeFlags)
+                       v0.AuxInt = int32ToAuxInt(127)
+                       v0.AddArg(z)
+                       b.resetWithControl(BlockAMD64GT, v0)
+                       return true
+               }
                 // match: (GE (InvertFlags cmp) yes no)
                 // result: (LE cmp yes no)
                 for b.Controls[0].Op == OpAMD64InvertFlags {
@@ -31282,6 +31645,42 @@ func rewriteBlockAMD64(b *Block) bool {
                         return true
                 }
         case BlockAMD64LT:
+               // match: (LT c:(CMPQconst [128] z) yes no)
+               // cond: c.Uses == 1
+               // result: (LE (CMPQconst [127] z) yes no)
+               for b.Controls[0].Op == OpAMD64CMPQconst {
+                       c := b.Controls[0]
+                       if auxIntToInt32(c.AuxInt) != 128 {
+                               break
+                       }
+                       z := c.Args[0]
+                       if !(c.Uses == 1) {
+                               break
+                       }
+                       v0 := b.NewValue0(c.Pos, OpAMD64CMPQconst, types.TypeFlags)
+                       v0.AuxInt = int32ToAuxInt(127)
+                       v0.AddArg(z)
+                       b.resetWithControl(BlockAMD64LE, v0)
+                       return true
+               }
+               // match: (LT c:(CMPLconst [128] z) yes no)
+               // cond: c.Uses == 1
+               // result: (LE (CMPLconst [127] z) yes no)
+               for b.Controls[0].Op == OpAMD64CMPLconst {
+                       c := b.Controls[0]
+                       if auxIntToInt32(c.AuxInt) != 128 {
+                               break
+                       }
+                       z := c.Args[0]
+                       if !(c.Uses == 1) {
+                               break
+                       }
+                       v0 := b.NewValue0(c.Pos, OpAMD64CMPLconst, types.TypeFlags)
+                       v0.AuxInt = int32ToAuxInt(127)
+                       v0.AddArg(z)
+                       b.resetWithControl(BlockAMD64LE, v0)
+                       return true
+               }
                 // match: (LT (InvertFlags cmp) yes no)
                 // result: (GT cmp yes no)
                 for b.Controls[0].Op == OpAMD64InvertFlags {
diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go

index 5fbb31c00c8cd87b15bff18bbfe76ac44ea02dbe..702ea275cc9b39956141ce72c254412efa868dcf 100644 (file)
--- a/test/codegen/comparisons.go
+++ b/test/codegen/comparisons.go
@@ -730,6 +730,54 @@ func cmpToCmnLessThan(a, b, c, d int) int {
         return c1 + c2 + c3 + c4
  }
  
+func less128Signed32(x int32) bool {
+       // amd64:`CMPL.*127`
+       // amd64:`SETLE`
+       return x < 128
+}
+
+func less128Signed64(x int64) bool {
+       // amd64:`CMPQ.*127`
+       // amd64:`SETLE`
+       return x < 128
+}
+
+func less128Unsigned32(x uint32) bool {
+       // amd64:`CMPL.*127`
+       // amd64:`SETLS`
+       return x < 128
+}
+
+func less128Unsigned64(x uint64) bool {
+       // amd64:`CMPQ.*127`
+       // amd64:`SETLS`
+       return x < 128
+}
+
+func ge128Unsigned32(x uint32) bool {
+       // amd64:`CMPL.*127`
+       // amd64:`SETHI`
+       return x >= 128
+}
+
+func ge128Unsigned64(x uint64) bool {
+       // amd64:`CMPQ.*127`
+       // amd64:`SETHI`
+       return x >= 128
+}
+
+func ge128Signed32(x int32) bool {
+       // amd64:`CMPL.*127`
+       // amd64:`SETGT`
+       return x >= 128
+}
+
+func ge128Signed64(x int64) bool {
+       // amd64:`CMPQ.*127`
+       // amd64:`SETGT`
+       return x >= 128
+}
+
  func cmpToCmnGreaterThanEqual(a, b, c, d int) int {
         var c1, c2, c3, c4 int
         // arm64:`CMN`,`CSET\tPL`,-`CMP`
author	Jakub Ciolek <jakub@ciolek.dev>
	Fri, 3 Jan 2025 12:52:11 +0000 (13:52 +0100)
committer	Keith Randall <khr@golang.org>
	Sun, 16 Feb 2025 15:23:13 +0000 (07:23 -0800)
src/cmd/compile/internal/ssa/_gen/AMD64.rules		patch \| blob \| history
src/cmd/compile/internal/ssa/rewriteAMD64.go		patch \| blob \| history
test/codegen/comparisons.go		patch \| blob \| history