b.AuxInt = 0
}
+// resetWithControl resets b and adds control v.
+// It is equivalent to b.Reset(kind); b.AddControl(v),
+// except that it is one call instead of two and avoids a bounds check.
+// It is intended for use by rewrite rules, where this matters.
+func (b *Block) resetWithControl(kind BlockKind, v *Value) {
+ b.Kind = kind
+ b.ResetControls()
+ b.Aux = nil
+ b.AuxInt = 0
+ b.Controls[0] = v
+ v.Uses++
+}
+
+// resetWithControl2 resets b and adds controls v and w.
+// It is equivalent to b.Reset(kind); b.AddControl(v); b.AddControl(w),
+// except that it is one call instead of three and avoids two bounds checks.
+// It is intended for use by rewrite rules, where this matters.
+func (b *Block) resetWithControl2(kind BlockKind, v, w *Value) {
+ b.Kind = kind
+ b.ResetControls()
+ b.Aux = nil
+ b.AuxInt = 0
+ b.Controls[0] = v
+ b.Controls[1] = w
+ v.Uses++
+ w.Uses++
+}
+
// AddEdgeTo adds an edge from block b to block c. Used during building of the
// SSA graph; do not use on an already-completed SSA graph.
func (b *Block) AddEdgeTo(c *Block) {
}
blockName, _ := getBlockInfo(outop, arch)
- rr.add(stmtf("b.Reset(%s)", blockName))
+ var genControls [2]string
for i, control := range t[:outdata.controls] {
// Select a source position for any new control values.
// TODO: does it always make sense to use the source position
}
// Generate a new control value (or copy an existing value).
- v := genResult0(rr, arch, control, false, false, newpos)
- rr.add(stmtf("b.AddControl(%s)", v))
+ genControls[i] = genResult0(rr, arch, control, false, false, newpos)
}
+ switch outdata.controls {
+ case 0:
+ rr.add(stmtf("b.Reset(%s)", blockName))
+ case 1:
+ rr.add(stmtf("b.resetWithControl(%s, %s)", blockName, genControls[0]))
+ case 2:
+ rr.add(stmtf("b.resetWithControl2(%s, %s, %s)", blockName, genControls[0], genControls[1]))
+ default:
+ log.Fatalf("too many controls: %d", outdata.controls)
+ }
+
if auxint != "" {
rr.add(stmtf("b.AuxInt = %s", auxint))
}
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386EQ)
- b.AddControl(cmp)
+ b.resetWithControl(Block386EQ, cmp)
return true
}
// match: (EQ (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386LE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LE, cmp)
return true
}
// match: (GE (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386LT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LT, cmp)
return true
}
// match: (GT (FlagEQ) yes no)
for b.Controls[0].Op == Op386SETL {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386LT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LT, cmp)
return true
}
// match: (If (SETLE cmp) yes no)
for b.Controls[0].Op == Op386SETLE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386LE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LE, cmp)
return true
}
// match: (If (SETG cmp) yes no)
for b.Controls[0].Op == Op386SETG {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386GT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GT, cmp)
return true
}
// match: (If (SETGE cmp) yes no)
for b.Controls[0].Op == Op386SETGE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386GE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GE, cmp)
return true
}
// match: (If (SETEQ cmp) yes no)
for b.Controls[0].Op == Op386SETEQ {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386EQ)
- b.AddControl(cmp)
+ b.resetWithControl(Block386EQ, cmp)
return true
}
// match: (If (SETNE cmp) yes no)
for b.Controls[0].Op == Op386SETNE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386NE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386NE, cmp)
return true
}
// match: (If (SETB cmp) yes no)
for b.Controls[0].Op == Op386SETB {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386ULT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULT, cmp)
return true
}
// match: (If (SETBE cmp) yes no)
for b.Controls[0].Op == Op386SETBE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386ULE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULE, cmp)
return true
}
// match: (If (SETA cmp) yes no)
for b.Controls[0].Op == Op386SETA {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGT, cmp)
return true
}
// match: (If (SETAE cmp) yes no)
for b.Controls[0].Op == Op386SETAE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGE, cmp)
return true
}
// match: (If (SETO cmp) yes no)
for b.Controls[0].Op == Op386SETO {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386OS)
- b.AddControl(cmp)
+ b.resetWithControl(Block386OS, cmp)
return true
}
// match: (If (SETGF cmp) yes no)
for b.Controls[0].Op == Op386SETGF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGT, cmp)
return true
}
// match: (If (SETGEF cmp) yes no)
for b.Controls[0].Op == Op386SETGEF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGE, cmp)
return true
}
// match: (If (SETEQF cmp) yes no)
for b.Controls[0].Op == Op386SETEQF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386EQF)
- b.AddControl(cmp)
+ b.resetWithControl(Block386EQF, cmp)
return true
}
// match: (If (SETNEF cmp) yes no)
for b.Controls[0].Op == Op386SETNEF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386NEF)
- b.AddControl(cmp)
+ b.resetWithControl(Block386NEF, cmp)
return true
}
// match: (If cond yes no)
// result: (NE (TESTB cond cond) yes no)
for {
cond := b.Controls[0]
- b.Reset(Block386NE)
v0 := b.NewValue0(cond.Pos, Op386TESTB, types.TypeFlags)
v0.AddArg2(cond, cond)
- b.AddControl(v0)
+ b.resetWithControl(Block386NE, v0)
return true
}
case Block386LE:
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386GE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GE, cmp)
return true
}
// match: (LE (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386GT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GT, cmp)
return true
}
// match: (LT (FlagEQ) yes no)
if v_0_1.Op != Op386SETL || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386LT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LT, cmp)
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
if v_0_1.Op != Op386SETLE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386LE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386LE, cmp)
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
if v_0_1.Op != Op386SETG || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386GT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GT, cmp)
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
if v_0_1.Op != Op386SETGE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386GE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386GE, cmp)
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
if v_0_1.Op != Op386SETEQ || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386EQ)
- b.AddControl(cmp)
+ b.resetWithControl(Block386EQ, cmp)
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
if v_0_1.Op != Op386SETNE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386NE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386NE, cmp)
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
if v_0_1.Op != Op386SETB || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386ULT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULT, cmp)
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
if v_0_1.Op != Op386SETBE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386ULE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULE, cmp)
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
if v_0_1.Op != Op386SETA || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386UGT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGT, cmp)
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
if v_0_1.Op != Op386SETAE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386UGE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGE, cmp)
return true
}
// match: (NE (TESTB (SETO cmp) (SETO cmp)) yes no)
if v_0_1.Op != Op386SETO || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386OS)
- b.AddControl(cmp)
+ b.resetWithControl(Block386OS, cmp)
return true
}
// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
if v_0_1.Op != Op386SETGF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386UGT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGT, cmp)
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
if v_0_1.Op != Op386SETGEF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386UGE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGE, cmp)
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
if v_0_1.Op != Op386SETEQF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386EQF)
- b.AddControl(cmp)
+ b.resetWithControl(Block386EQF, cmp)
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
if v_0_1.Op != Op386SETNEF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(Block386NEF)
- b.AddControl(cmp)
+ b.resetWithControl(Block386NEF, cmp)
return true
}
// match: (NE (InvertFlags cmp) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386NE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386NE, cmp)
return true
}
// match: (NE (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386ULE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULE, cmp)
return true
}
// match: (UGE (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386ULT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386ULT, cmp)
return true
}
// match: (UGT (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGE)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGE, cmp)
return true
}
// match: (ULE (FlagEQ) yes no)
for b.Controls[0].Op == Op386InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(Block386UGT)
- b.AddControl(cmp)
+ b.resetWithControl(Block386UGT, cmp)
return true
}
// match: (ULT (FlagEQ) yes no)
continue
}
y := v_0_1
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTL, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
continue
}
y := v_0_1
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(isUint32PowerOfTwo(c)) {
break
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = log2uint32(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
// match: (EQ (TESTQconst [c] x))
if !(isUint64PowerOfTwo(c)) {
break
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = log2(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
// match: (EQ (TESTQ (MOVQconst [c]) x))
if !(isUint64PowerOfTwo(c)) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = log2(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 63
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 31
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 63
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64UGE)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = 31
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64UGE, v0)
return true
}
break
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64EQ, cmp)
return true
}
// match: (EQ (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64LE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LE, cmp)
return true
}
// match: (GE (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64LT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LT, cmp)
return true
}
// match: (GT (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64SETL {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64LT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LT, cmp)
return true
}
// match: (If (SETLE cmp) yes no)
for b.Controls[0].Op == OpAMD64SETLE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64LE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LE, cmp)
return true
}
// match: (If (SETG cmp) yes no)
for b.Controls[0].Op == OpAMD64SETG {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64GT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GT, cmp)
return true
}
// match: (If (SETGE cmp) yes no)
for b.Controls[0].Op == OpAMD64SETGE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64GE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GE, cmp)
return true
}
// match: (If (SETEQ cmp) yes no)
for b.Controls[0].Op == OpAMD64SETEQ {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64EQ, cmp)
return true
}
// match: (If (SETNE cmp) yes no)
for b.Controls[0].Op == OpAMD64SETNE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64NE, cmp)
return true
}
// match: (If (SETB cmp) yes no)
for b.Controls[0].Op == OpAMD64SETB {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64ULT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULT, cmp)
return true
}
// match: (If (SETBE cmp) yes no)
for b.Controls[0].Op == OpAMD64SETBE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64ULE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULE, cmp)
return true
}
// match: (If (SETA cmp) yes no)
for b.Controls[0].Op == OpAMD64SETA {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGT, cmp)
return true
}
// match: (If (SETAE cmp) yes no)
for b.Controls[0].Op == OpAMD64SETAE {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGE, cmp)
return true
}
// match: (If (SETO cmp) yes no)
for b.Controls[0].Op == OpAMD64SETO {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64OS)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64OS, cmp)
return true
}
// match: (If (SETGF cmp) yes no)
for b.Controls[0].Op == OpAMD64SETGF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGT, cmp)
return true
}
// match: (If (SETGEF cmp) yes no)
for b.Controls[0].Op == OpAMD64SETGEF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGE, cmp)
return true
}
// match: (If (SETEQF cmp) yes no)
for b.Controls[0].Op == OpAMD64SETEQF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64EQF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64EQF, cmp)
return true
}
// match: (If (SETNEF cmp) yes no)
for b.Controls[0].Op == OpAMD64SETNEF {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64NEF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64NEF, cmp)
return true
}
// match: (If cond yes no)
// result: (NE (TESTB cond cond) yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockAMD64NE)
v0 := b.NewValue0(cond.Pos, OpAMD64TESTB, types.TypeFlags)
v0.AddArg2(cond, cond)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64NE, v0)
return true
}
case BlockAMD64LE:
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64GE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GE, cmp)
return true
}
// match: (LE (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64GT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GT, cmp)
return true
}
// match: (LT (FlagEQ) yes no)
if v_0_1.Op != OpAMD64SETL || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64LT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LT, cmp)
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
if v_0_1.Op != OpAMD64SETLE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64LE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64LE, cmp)
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
if v_0_1.Op != OpAMD64SETG || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64GT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GT, cmp)
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
if v_0_1.Op != OpAMD64SETGE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64GE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64GE, cmp)
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
if v_0_1.Op != OpAMD64SETEQ || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64EQ, cmp)
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
if v_0_1.Op != OpAMD64SETNE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64NE, cmp)
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
if v_0_1.Op != OpAMD64SETB || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64ULT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULT, cmp)
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
if v_0_1.Op != OpAMD64SETBE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64ULE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULE, cmp)
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
if v_0_1.Op != OpAMD64SETA || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGT, cmp)
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
if v_0_1.Op != OpAMD64SETAE || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGE, cmp)
return true
}
// match: (NE (TESTB (SETO cmp) (SETO cmp)) yes no)
if v_0_1.Op != OpAMD64SETO || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64OS)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64OS, cmp)
return true
}
// match: (NE (TESTL (SHLL (MOVLconst [1]) x) y))
continue
}
y := v_0_1
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTL, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
continue
}
y := v_0_1
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(isUint32PowerOfTwo(c)) {
break
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = log2uint32(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
// match: (NE (TESTQconst [c] x))
if !(isUint64PowerOfTwo(c)) {
break
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = log2(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
// match: (NE (TESTQ (MOVQconst [c]) x))
if !(isUint64PowerOfTwo(c)) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = log2(c)
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 63
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 31
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTQconst, types.TypeFlags)
v0.AuxInt = 63
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if !(z1 == z2) {
continue
}
- b.Reset(BlockAMD64ULT)
v0 := b.NewValue0(v_0.Pos, OpAMD64BTLconst, types.TypeFlags)
v0.AuxInt = 31
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockAMD64ULT, v0)
return true
}
break
if v_0_1.Op != OpAMD64SETGF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGT, cmp)
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
if v_0_1.Op != OpAMD64SETGEF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGE, cmp)
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
if v_0_1.Op != OpAMD64SETEQF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64EQF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64EQF, cmp)
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
if v_0_1.Op != OpAMD64SETNEF || cmp != v_0_1.Args[0] {
break
}
- b.Reset(BlockAMD64NEF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64NEF, cmp)
return true
}
// match: (NE (InvertFlags cmp) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64NE, cmp)
return true
}
// match: (NE (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64ULE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULE, cmp)
return true
}
// match: (UGE (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64ULT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64ULT, cmp)
return true
}
// match: (UGT (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGE, cmp)
return true
}
// match: (ULE (FlagEQ) yes no)
for b.Controls[0].Op == OpAMD64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockAMD64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockAMD64UGT, cmp)
return true
}
// match: (ULT (FlagEQ) yes no)
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMEQ, cmp)
return true
}
// match: (EQ (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
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.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
// match: (EQ (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMEQ)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMEQ, v0)
return true
}
case BlockARMGE:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMLE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMLE, cmp)
return true
}
// match: (GE (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
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.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGE, v0)
return true
}
case BlockARMGT:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMLT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMLT, cmp)
return true
}
// match: (GT (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
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.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMGT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMGT, v0)
return true
}
case BlockIf:
for b.Controls[0].Op == OpARMEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMEQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMEQ, cc)
return true
}
// match: (If (NotEqual cc) yes no)
for b.Controls[0].Op == OpARMNotEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMNE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMNE, cc)
return true
}
// match: (If (LessThan cc) yes no)
for b.Controls[0].Op == OpARMLessThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMLT, cc)
return true
}
// match: (If (LessThanU cc) yes no)
for b.Controls[0].Op == OpARMLessThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMULT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMULT, cc)
return true
}
// match: (If (LessEqual cc) yes no)
for b.Controls[0].Op == OpARMLessEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMLE, cc)
return true
}
// match: (If (LessEqualU cc) yes no)
for b.Controls[0].Op == OpARMLessEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMULE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMULE, cc)
return true
}
// match: (If (GreaterThan cc) yes no)
for b.Controls[0].Op == OpARMGreaterThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMGT, cc)
return true
}
// match: (If (GreaterThanU cc) yes no)
for b.Controls[0].Op == OpARMGreaterThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMUGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMUGT, cc)
return true
}
// match: (If (GreaterEqual cc) yes no)
for b.Controls[0].Op == OpARMGreaterEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMGE, cc)
return true
}
// match: (If (GreaterEqualU cc) yes no)
for b.Controls[0].Op == OpARMGreaterEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARMUGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMUGE, cc)
return true
}
// match: (If cond yes no)
// result: (NE (CMPconst [0] cond) yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockARMNE)
v0 := b.NewValue0(cond.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(cond)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
case BlockARMLE:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMGE, cmp)
return true
}
// match: (LE (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
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.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLE, v0)
return true
}
case BlockARMLT:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMGT, cmp)
return true
}
// match: (LT (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
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.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMLT)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMLT, v0)
return true
}
case BlockARMNE:
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMEQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMEQ, cc)
return true
}
// match: (NE (CMPconst [0] (NotEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMNE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMNE, cc)
return true
}
// match: (NE (CMPconst [0] (LessThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMLT, cc)
return true
}
// match: (NE (CMPconst [0] (LessThanU cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMULT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMULT, cc)
return true
}
// match: (NE (CMPconst [0] (LessEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMLE, cc)
return true
}
// match: (NE (CMPconst [0] (LessEqualU cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMULE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMULE, cc)
return true
}
// match: (NE (CMPconst [0] (GreaterThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMGT, cc)
return true
}
// match: (NE (CMPconst [0] (GreaterThanU cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMUGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMUGT, cc)
return true
}
// match: (NE (CMPconst [0] (GreaterEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMGE, cc)
return true
}
// match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockARMUGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARMUGE, cc)
return true
}
// match: (NE (FlagEQ) yes no)
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMNE, cmp)
return true
}
// match: (NE (CMPconst [0] l:(SUB x y)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(MULS x y a)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARMMUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADD x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
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.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDconst [c] x)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(AND x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XOR x y)) yes no)
if !(l.Uses == 1) {
continue
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
break
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
// match: (NE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
if !(l.Uses == 1) {
break
}
- b.Reset(BlockARMNE)
v0 := b.NewValue0(v_0.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg3(x, y, z)
- b.AddControl(v0)
+ b.resetWithControl(BlockARMNE, v0)
return true
}
case BlockARMUGE:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMULE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMULE, cmp)
return true
}
case BlockARMUGT:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMULT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMULT, cmp)
return true
}
case BlockARMULE:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMUGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMUGE, cmp)
return true
}
case BlockARMULT:
for b.Controls[0].Op == OpARMInvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARMUGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARMUGT, cmp)
return true
}
}
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64Z)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64Z, x)
return true
}
// match: (EQ (CMPWconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64ZW)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64ZW, x)
return true
}
// match: (EQ (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64EQ)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64EQ, v0)
return true
}
// match: (EQ (TSTconst [c] x) yes no)
if !(oneBit(c)) {
break
}
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = ntz(c)
return true
}
if !(oneBit(int64(uint32(c)))) {
break
}
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = ntz(int64(uint32(c)))
return true
}
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64EQ, cmp)
return true
}
case BlockARM64FGE:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64FLE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64FLE, cmp)
return true
}
case BlockARM64FGT:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64FLT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64FLT, cmp)
return true
}
case BlockARM64FLE:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64FGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64FGE, cmp)
return true
}
case BlockARM64FLT:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64FGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64FGT, cmp)
return true
}
case BlockARM64GE:
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GE, v0)
return true
}
// match: (GE (CMPWconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = int64(31)
return true
}
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = int64(63)
return true
}
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64LE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64LE, cmp)
return true
}
case BlockARM64GT:
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64GT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64GT, v0)
return true
}
// match: (GT (FlagEQ) yes no)
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64LT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64LT, cmp)
return true
}
case BlockIf:
for b.Controls[0].Op == OpARM64Equal {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64EQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64EQ, cc)
return true
}
// match: (If (NotEqual cc) yes no)
for b.Controls[0].Op == OpARM64NotEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64NE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64NE, cc)
return true
}
// match: (If (LessThan cc) yes no)
for b.Controls[0].Op == OpARM64LessThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64LT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64LT, cc)
return true
}
// match: (If (LessThanU cc) yes no)
for b.Controls[0].Op == OpARM64LessThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64ULT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64ULT, cc)
return true
}
// match: (If (LessEqual cc) yes no)
for b.Controls[0].Op == OpARM64LessEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64LE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64LE, cc)
return true
}
// match: (If (LessEqualU cc) yes no)
for b.Controls[0].Op == OpARM64LessEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64ULE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64ULE, cc)
return true
}
// match: (If (GreaterThan cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64GT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64GT, cc)
return true
}
// match: (If (GreaterThanU cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64UGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64UGT, cc)
return true
}
// match: (If (GreaterEqual cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64GE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64GE, cc)
return true
}
// match: (If (GreaterEqualU cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64UGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64UGE, cc)
return true
}
// match: (If (LessThanF cc) yes no)
for b.Controls[0].Op == OpARM64LessThanF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FLT, cc)
return true
}
// match: (If (LessEqualF cc) yes no)
for b.Controls[0].Op == OpARM64LessEqualF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FLE, cc)
return true
}
// match: (If (GreaterThanF cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThanF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FGT, cc)
return true
}
// match: (If (GreaterEqualF cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqualF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FGE, cc)
return true
}
// match: (If cond yes no)
// result: (NZ cond yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockARM64NZ)
- b.AddControl(cond)
+ b.resetWithControl(BlockARM64NZ, cond)
return true
}
case BlockARM64LE:
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LE, v0)
return true
}
// match: (LE (FlagEQ) yes no)
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64GE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64GE, cmp)
return true
}
case BlockARM64LT:
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64LT)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64LT, v0)
return true
}
// match: (LT (CMPWconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = int64(31)
return true
}
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = int64(63)
return true
}
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64GT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64GT, cmp)
return true
}
case BlockARM64NE:
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64TST, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
break
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64TSTconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPWconst [0] x:(ADDconst [c] y)) yes no)
if !(x.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNWconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPconst [0] z:(ADD x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
break
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPW x z:(NEG y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64NZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64NZ, x)
return true
}
// match: (NE (CMPWconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockARM64NZW)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64NZW, x)
return true
}
// match: (NE (CMPconst [0] z:(MADD a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMN, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPconst [0] z:(MSUB a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMP, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MUL, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPWconst [0] z:(MADDW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMNW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (CMPWconst [0] z:(MSUBW a x y)) yes no)
if !(z.Uses == 1) {
break
}
- b.Reset(BlockARM64NE)
v0 := b.NewValue0(v_0.Pos, OpARM64CMPW, types.TypeFlags)
v1 := b.NewValue0(v_0.Pos, OpARM64MULW, x.Type)
v1.AddArg2(x, y)
v0.AddArg2(a, v1)
- b.AddControl(v0)
+ b.resetWithControl(BlockARM64NE, v0)
return true
}
// match: (NE (TSTconst [c] x) yes no)
if !(oneBit(c)) {
break
}
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = ntz(c)
return true
}
if !(oneBit(int64(uint32(c)))) {
break
}
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = ntz(int64(uint32(c)))
return true
}
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64NE, cmp)
return true
}
case BlockARM64NZ:
for b.Controls[0].Op == OpARM64Equal {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64EQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64EQ, cc)
return true
}
// match: (NZ (NotEqual cc) yes no)
for b.Controls[0].Op == OpARM64NotEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64NE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64NE, cc)
return true
}
// match: (NZ (LessThan cc) yes no)
for b.Controls[0].Op == OpARM64LessThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64LT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64LT, cc)
return true
}
// match: (NZ (LessThanU cc) yes no)
for b.Controls[0].Op == OpARM64LessThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64ULT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64ULT, cc)
return true
}
// match: (NZ (LessEqual cc) yes no)
for b.Controls[0].Op == OpARM64LessEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64LE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64LE, cc)
return true
}
// match: (NZ (LessEqualU cc) yes no)
for b.Controls[0].Op == OpARM64LessEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64ULE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64ULE, cc)
return true
}
// match: (NZ (GreaterThan cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64GT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64GT, cc)
return true
}
// match: (NZ (GreaterThanU cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThanU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64UGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64UGT, cc)
return true
}
// match: (NZ (GreaterEqual cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64GE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64GE, cc)
return true
}
// match: (NZ (GreaterEqualU cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqualU {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64UGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64UGE, cc)
return true
}
// match: (NZ (LessThanF cc) yes no)
for b.Controls[0].Op == OpARM64LessThanF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FLT, cc)
return true
}
// match: (NZ (LessEqualF cc) yes no)
for b.Controls[0].Op == OpARM64LessEqualF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FLE, cc)
return true
}
// match: (NZ (GreaterThanF cc) yes no)
for b.Controls[0].Op == OpARM64GreaterThanF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FGT, cc)
return true
}
// match: (NZ (GreaterEqualF cc) yes no)
for b.Controls[0].Op == OpARM64GreaterEqualF {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockARM64FGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockARM64FGE, cc)
return true
}
// match: (NZ (ANDconst [c] x) yes no)
if !(oneBit(c)) {
break
}
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = ntz(c)
return true
}
if !(oneBit(int64(uint32(c)))) {
break
}
- b.Reset(BlockARM64TBNZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBNZ, x)
b.Aux = ntz(int64(uint32(c)))
return true
}
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64ULE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64ULE, cmp)
return true
}
case BlockARM64UGT:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64ULT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64ULT, cmp)
return true
}
case BlockARM64ULE:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64UGE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64UGE, cmp)
return true
}
case BlockARM64ULT:
for b.Controls[0].Op == OpARM64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockARM64UGT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockARM64UGT, cmp)
return true
}
case BlockARM64Z:
if !(oneBit(c)) {
break
}
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = ntz(c)
return true
}
if !(oneBit(int64(uint32(c)))) {
break
}
- b.Reset(BlockARM64TBZ)
- b.AddControl(x)
+ b.resetWithControl(BlockARM64TBZ, x)
b.Aux = ntz(int64(uint32(c)))
return true
}
for b.Controls[0].Op == OpMIPSFPFlagTrue {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPSFPF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSFPF, cmp)
return true
}
// match: (EQ (FPFlagFalse cmp) yes no)
for b.Controls[0].Op == OpMIPSFPFlagFalse {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPSFPT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSFPT, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGT _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTU _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTconst _)) yes no)
if cmp.Op != OpMIPSSGTconst {
break
}
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUconst _)) yes no)
if cmp.Op != OpMIPSSGTUconst {
break
}
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTzero _)) yes no)
if cmp.Op != OpMIPSSGTzero {
break
}
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUzero _)) yes no)
if cmp.Op != OpMIPSSGTUzero {
break
}
- b.Reset(BlockMIPSNE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSNE, cmp)
return true
}
// match: (EQ (SGTUconst [1] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPSNE)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSNE, x)
return true
}
// match: (EQ (SGTUzero x) yes no)
for b.Controls[0].Op == OpMIPSSGTUzero {
v_0 := b.Controls[0]
x := v_0.Args[0]
- b.Reset(BlockMIPSEQ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSEQ, x)
return true
}
// match: (EQ (SGTconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPSGEZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSGEZ, x)
return true
}
// match: (EQ (SGTzero x) yes no)
for b.Controls[0].Op == OpMIPSSGTzero {
v_0 := b.Controls[0]
x := v_0.Args[0]
- b.Reset(BlockMIPSLEZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSLEZ, x)
return true
}
// match: (EQ (MOVWconst [0]) yes no)
// result: (NE cond yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockMIPSNE)
- b.AddControl(cond)
+ b.resetWithControl(BlockMIPSNE, cond)
return true
}
case BlockMIPSLEZ:
for b.Controls[0].Op == OpMIPSFPFlagTrue {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPSFPT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSFPT, cmp)
return true
}
// match: (NE (FPFlagFalse cmp) yes no)
for b.Controls[0].Op == OpMIPSFPFlagFalse {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPSFPF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSFPF, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGT _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTU _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTconst _)) yes no)
if cmp.Op != OpMIPSSGTconst {
break
}
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTUconst _)) yes no)
if cmp.Op != OpMIPSSGTUconst {
break
}
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTzero _)) yes no)
if cmp.Op != OpMIPSSGTzero {
break
}
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTUzero _)) yes no)
if cmp.Op != OpMIPSSGTUzero {
break
}
- b.Reset(BlockMIPSEQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPSEQ, cmp)
return true
}
// match: (NE (SGTUconst [1] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPSEQ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSEQ, x)
return true
}
// match: (NE (SGTUzero x) yes no)
for b.Controls[0].Op == OpMIPSSGTUzero {
v_0 := b.Controls[0]
x := v_0.Args[0]
- b.Reset(BlockMIPSNE)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSNE, x)
return true
}
// match: (NE (SGTconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPSLTZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSLTZ, x)
return true
}
// match: (NE (SGTzero x) yes no)
for b.Controls[0].Op == OpMIPSSGTzero {
v_0 := b.Controls[0]
x := v_0.Args[0]
- b.Reset(BlockMIPSGTZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPSGTZ, x)
return true
}
// match: (NE (MOVWconst [0]) yes no)
for b.Controls[0].Op == OpMIPS64FPFlagTrue {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPS64FPF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64FPF, cmp)
return true
}
// match: (EQ (FPFlagFalse cmp) yes no)
for b.Controls[0].Op == OpMIPS64FPFlagFalse {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPS64FPT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64FPT, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGT _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPS64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64NE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTU _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPS64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64NE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTconst _)) yes no)
if cmp.Op != OpMIPS64SGTconst {
break
}
- b.Reset(BlockMIPS64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64NE, cmp)
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUconst _)) yes no)
if cmp.Op != OpMIPS64SGTUconst {
break
}
- b.Reset(BlockMIPS64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64NE, cmp)
return true
}
// match: (EQ (SGTUconst [1] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPS64NE)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64NE, x)
return true
}
// match: (EQ (SGTU x (MOVVconst [0])) yes no)
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 0 {
break
}
- b.Reset(BlockMIPS64EQ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64EQ, x)
return true
}
// match: (EQ (SGTconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPS64GEZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64GEZ, x)
return true
}
// match: (EQ (SGT x (MOVVconst [0])) yes no)
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 0 {
break
}
- b.Reset(BlockMIPS64LEZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64LEZ, x)
return true
}
// match: (EQ (MOVVconst [0]) yes no)
// result: (NE cond yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockMIPS64NE)
- b.AddControl(cond)
+ b.resetWithControl(BlockMIPS64NE, cond)
return true
}
case BlockMIPS64LEZ:
for b.Controls[0].Op == OpMIPS64FPFlagTrue {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPS64FPT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64FPT, cmp)
return true
}
// match: (NE (FPFlagFalse cmp) yes no)
for b.Controls[0].Op == OpMIPS64FPFlagFalse {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockMIPS64FPF)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64FPF, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGT _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPS64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64EQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTU _ _)) yes no)
break
}
_ = cmp.Args[1]
- b.Reset(BlockMIPS64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64EQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTconst _)) yes no)
if cmp.Op != OpMIPS64SGTconst {
break
}
- b.Reset(BlockMIPS64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64EQ, cmp)
return true
}
// match: (NE (XORconst [1] cmp:(SGTUconst _)) yes no)
if cmp.Op != OpMIPS64SGTUconst {
break
}
- b.Reset(BlockMIPS64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockMIPS64EQ, cmp)
return true
}
// match: (NE (SGTUconst [1] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPS64EQ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64EQ, x)
return true
}
// match: (NE (SGTU x (MOVVconst [0])) yes no)
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 0 {
break
}
- b.Reset(BlockMIPS64NE)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64NE, x)
return true
}
// match: (NE (SGTconst [0] x) yes no)
break
}
x := v_0.Args[0]
- b.Reset(BlockMIPS64LTZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64LTZ, x)
return true
}
// match: (NE (SGT x (MOVVconst [0])) yes no)
if v_0_1.Op != OpMIPS64MOVVconst || v_0_1.AuxInt != 0 {
break
}
- b.Reset(BlockMIPS64GTZ)
- b.AddControl(x)
+ b.resetWithControl(BlockMIPS64GTZ, x)
return true
}
// match: (NE (MOVVconst [0]) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
// match: (EQ (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
// match: (EQ (FlagEQ) yes no)
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64EQ)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64EQ, cmp)
return true
}
// match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
// match: (EQ (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
// match: (EQ (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64EQ)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64EQ, v0)
return true
}
break
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64LE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64LE, cmp)
return true
}
// match: (GE (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64GE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GE, v0)
return true
}
// match: (GE (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64GE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GE, v0)
return true
}
// match: (GE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GE)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GE, v0)
return true
}
break
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64LT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64LT, cmp)
return true
}
// match: (GT (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64GT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GT, v0)
return true
}
// match: (GT (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64GT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GT, v0)
return true
}
// match: (GT (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64GT)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64GT, v0)
return true
}
break
for b.Controls[0].Op == OpPPC64Equal {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64EQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64EQ, cc)
return true
}
// match: (If (NotEqual cc) yes no)
for b.Controls[0].Op == OpPPC64NotEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64NE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64NE, cc)
return true
}
// match: (If (LessThan cc) yes no)
for b.Controls[0].Op == OpPPC64LessThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64LT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64LT, cc)
return true
}
// match: (If (LessEqual cc) yes no)
for b.Controls[0].Op == OpPPC64LessEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64LE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64LE, cc)
return true
}
// match: (If (GreaterThan cc) yes no)
for b.Controls[0].Op == OpPPC64GreaterThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64GT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64GT, cc)
return true
}
// match: (If (GreaterEqual cc) yes no)
for b.Controls[0].Op == OpPPC64GreaterEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64GE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64GE, cc)
return true
}
// match: (If (FLessThan cc) yes no)
for b.Controls[0].Op == OpPPC64FLessThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64FLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FLT, cc)
return true
}
// match: (If (FLessEqual cc) yes no)
for b.Controls[0].Op == OpPPC64FLessEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64FLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FLE, cc)
return true
}
// match: (If (FGreaterThan cc) yes no)
for b.Controls[0].Op == OpPPC64FGreaterThan {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64FGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FGT, cc)
return true
}
// match: (If (FGreaterEqual cc) yes no)
for b.Controls[0].Op == OpPPC64FGreaterEqual {
v_0 := b.Controls[0]
cc := v_0.Args[0]
- b.Reset(BlockPPC64FGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FGE, cc)
return true
}
// match: (If cond yes no)
// result: (NE (CMPWconst [0] cond) yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(cond.Pos, OpPPC64CMPWconst, types.TypeFlags)
v0.AuxInt = 0
v0.AddArg(cond)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
case BlockPPC64LE:
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64GE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64GE, cmp)
return true
}
// match: (LE (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64LE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LE, v0)
return true
}
// match: (LE (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64LE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LE, v0)
return true
}
// match: (LE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LE)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LE, v0)
return true
}
break
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64GT)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64GT, cmp)
return true
}
// match: (LT (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64LT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LT, v0)
return true
}
// match: (LT (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64LT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LT, v0)
return true
}
// match: (LT (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LT)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LT, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64LT)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64LT, v0)
return true
}
break
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64EQ)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64EQ, cc)
return true
}
// match: (NE (CMPWconst [0] (NotEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64NE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64NE, cc)
return true
}
// match: (NE (CMPWconst [0] (LessThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64LT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64LT, cc)
return true
}
// match: (NE (CMPWconst [0] (LessEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64LE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64LE, cc)
return true
}
// match: (NE (CMPWconst [0] (GreaterThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64GT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64GT, cc)
return true
}
// match: (NE (CMPWconst [0] (GreaterEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64GE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64GE, cc)
return true
}
// match: (NE (CMPWconst [0] (FLessThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64FLT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FLT, cc)
return true
}
// match: (NE (CMPWconst [0] (FLessEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64FLE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FLE, cc)
return true
}
// match: (NE (CMPWconst [0] (FGreaterThan cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64FGT)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FGT, cc)
return true
}
// match: (NE (CMPWconst [0] (FGreaterEqual cc)) yes no)
break
}
cc := v_0_0.Args[0]
- b.Reset(BlockPPC64FGE)
- b.AddControl(cc)
+ b.resetWithControl(BlockPPC64FGE, cc)
return true
}
// match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
// match: (NE (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
// match: (NE (FlagEQ) yes no)
for b.Controls[0].Op == OpPPC64InvertFlags {
v_0 := b.Controls[0]
cmp := v_0.Args[0]
- b.Reset(BlockPPC64NE)
- b.AddControl(cmp)
+ b.resetWithControl(BlockPPC64NE, cmp)
return true
}
// match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
// match: (NE (CMPWconst [0] (ANDconst [c] x)) yes no)
}
c := v_0_0.AuxInt
x := v_0_0.Args[0]
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCCconst, types.TypeFlags)
v0.AuxInt = c
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
// match: (NE (CMPconst [0] z:(AND x y)) yes no)
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ANDCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64ORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
break
if !(z.Uses == 1) {
continue
}
- b.Reset(BlockPPC64NE)
v0 := b.NewValue0(v_0.Pos, OpPPC64XORCC, types.TypeFlags)
v0.AddArg2(x, y)
- b.AddControl(v0)
+ b.resetWithControl(BlockPPC64NE, v0)
return true
}
break
// result: (BNE cond yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockRISCV64BNE)
- b.AddControl(cond)
+ b.resetWithControl(BlockRISCV64BNE, cond)
return true
}
}
y := v_0.Args[1]
x := v_0.Args[0]
c := b.Aux
- b.Reset(BlockS390XCGRJ)
- b.AddControl(x)
- b.AddControl(y)
+ b.resetWithControl2(BlockS390XCGRJ, x, y)
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
}
y := v_0.Args[1]
x := v_0.Args[0]
c := b.Aux
- b.Reset(BlockS390XCRJ)
- b.AddControl(x)
- b.AddControl(y)
+ b.resetWithControl2(BlockS390XCRJ, x, y)
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
}
y := v_0.Args[1]
x := v_0.Args[0]
c := b.Aux
- b.Reset(BlockS390XCLGRJ)
- b.AddControl(x)
- b.AddControl(y)
+ b.resetWithControl2(BlockS390XCLGRJ, x, y)
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
}
y := v_0.Args[1]
x := v_0.Args[0]
c := b.Aux
- b.Reset(BlockS390XCLRJ)
- b.AddControl(x)
- b.AddControl(y)
+ b.resetWithControl2(BlockS390XCLRJ, x, y)
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
}
if !(is8Bit(y)) {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
if !(is8Bit(y)) {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
if !(isU8Bit(y)) {
break
}
- b.Reset(BlockS390XCLGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLGIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
if !(isU8Bit(y)) {
break
}
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c.(s390x.CCMask) &^ s390x.Unordered
return true
if b.Aux != s390x.Less {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = 127
b.Aux = s390x.LessOrEqual
return true
if b.Aux != s390x.Less {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = 127
b.Aux = s390x.LessOrEqual
return true
if b.Aux != s390x.LessOrEqual {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = -128
b.Aux = s390x.Less
return true
if b.Aux != s390x.LessOrEqual {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = -128
b.Aux = s390x.Less
return true
if b.Aux != s390x.Greater {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = -128
b.Aux = s390x.GreaterOrEqual
return true
if b.Aux != s390x.Greater {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = -128
b.Aux = s390x.GreaterOrEqual
return true
if b.Aux != s390x.GreaterOrEqual {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = 127
b.Aux = s390x.Greater
return true
if b.Aux != s390x.GreaterOrEqual {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = 127
b.Aux = s390x.Greater
return true
if b.Aux != s390x.Less {
break
}
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = -1
b.Aux = s390x.LessOrEqual
return true
if b.Aux != s390x.Less {
break
}
- b.Reset(BlockS390XCLGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLGIJ, x)
b.AuxInt = -1
b.Aux = s390x.LessOrEqual
return true
if b.Aux != s390x.GreaterOrEqual {
break
}
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = -1
b.Aux = s390x.Greater
return true
if b.Aux != s390x.GreaterOrEqual {
break
}
- b.Reset(BlockS390XCLGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLGIJ, x)
b.AuxInt = -1
b.Aux = s390x.Greater
return true
v_0 := b.Controls[0]
cmp := v_0.Args[0]
c := b.Aux
- b.Reset(BlockS390XBRC)
- b.AddControl(cmp)
+ b.resetWithControl(BlockS390XBRC, cmp)
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
}
if !(is8Bit(y)) {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCGIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c
return true
if !(is8Bit(x)) {
break
}
- b.Reset(BlockS390XCGIJ)
- b.AddControl(y)
+ b.resetWithControl(BlockS390XCGIJ, y)
b.AuxInt = int64(int8(x))
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
if !(!is8Bit(y) && is32Bit(y)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(x.Pos, OpS390XCMPconst, types.TypeFlags)
v0.AuxInt = int64(int32(y))
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c
return true
}
if !(!is8Bit(x) && is32Bit(x)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(v_0.Pos, OpS390XCMPconst, types.TypeFlags)
v0.AuxInt = int64(int32(x))
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
}
x := v_0.Args[0]
y := b.AuxInt
c := b.Aux
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = y
b.Aux = c
return true
x := v_0.Args[0]
y := b.AuxInt
c := b.Aux
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = y
b.Aux = c
return true
if !(isU8Bit(y)) {
break
}
- b.Reset(BlockS390XCLGIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLGIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c
return true
if !(isU8Bit(x)) {
break
}
- b.Reset(BlockS390XCLGIJ)
- b.AddControl(y)
+ b.resetWithControl(BlockS390XCLGIJ, y)
b.AuxInt = int64(int8(x))
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
if !(!isU8Bit(y) && isU32Bit(y)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(x.Pos, OpS390XCMPUconst, types.TypeFlags)
v0.AuxInt = int64(int32(y))
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c
return true
}
if !(!isU8Bit(x) && isU32Bit(x)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(v_0.Pos, OpS390XCMPUconst, types.TypeFlags)
v0.AuxInt = int64(int32(x))
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
}
if b.AuxInt != 0 || b.Aux != s390x.LessOrGreater || !(int32(x) != 0) {
break
}
- b.Reset(BlockS390XBRC)
- b.AddControl(cmp)
+ b.resetWithControl(BlockS390XBRC, cmp)
b.Aux = d
return true
}
x := v_0.Args[0]
y := b.AuxInt
c := b.Aux
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = y
b.Aux = c
return true
x := v_0.Args[0]
y := b.AuxInt
c := b.Aux
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = y
b.Aux = c
return true
if !(isU8Bit(y)) {
break
}
- b.Reset(BlockS390XCLIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCLIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c
return true
if !(isU8Bit(x)) {
break
}
- b.Reset(BlockS390XCLIJ)
- b.AddControl(y)
+ b.resetWithControl(BlockS390XCLIJ, y)
b.AuxInt = int64(int8(x))
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
if !(!isU8Bit(y) && isU32Bit(y)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(x.Pos, OpS390XCMPWUconst, types.TypeFlags)
v0.AuxInt = int64(int32(y))
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c
return true
}
if !(!isU8Bit(x) && isU32Bit(x)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(v_0.Pos, OpS390XCMPWUconst, types.TypeFlags)
v0.AuxInt = int64(int32(x))
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
}
if !(is8Bit(y)) {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(x)
+ b.resetWithControl(BlockS390XCIJ, x)
b.AuxInt = int64(int8(y))
b.Aux = c
return true
if !(is8Bit(x)) {
break
}
- b.Reset(BlockS390XCIJ)
- b.AddControl(y)
+ b.resetWithControl(BlockS390XCIJ, y)
b.AuxInt = int64(int8(x))
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
if !(!is8Bit(y) && is32Bit(y)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(x.Pos, OpS390XCMPWconst, types.TypeFlags)
v0.AuxInt = int64(int32(y))
v0.AddArg(x)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c
return true
}
if !(!is8Bit(x) && is32Bit(x)) {
break
}
- b.Reset(BlockS390XBRC)
v0 := b.NewValue0(v_0.Pos, OpS390XCMPWconst, types.TypeFlags)
v0.AuxInt = int64(int32(x))
v0.AddArg(y)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XBRC, v0)
b.Aux = c.(s390x.CCMask).ReverseComparison()
return true
}
// result: (CLIJ {s390x.LessOrGreater} (MOVBZreg <typ.Bool> cond) [0] yes no)
for {
cond := b.Controls[0]
- b.Reset(BlockS390XCLIJ)
v0 := b.NewValue0(cond.Pos, OpS390XMOVBZreg, typ.Bool)
v0.AddArg(cond)
- b.AddControl(v0)
+ b.resetWithControl(BlockS390XCLIJ, v0)
b.AuxInt = 0
b.Aux = s390x.LessOrGreater
return true
for b.Controls[0].Op == OpNot {
v_0 := b.Controls[0]
cond := v_0.Args[0]
- b.Reset(BlockIf)
- b.AddControl(cond)
+ b.resetWithControl(BlockIf, cond)
b.swapSuccessors()
return true
}