{name: "MFVSRD", argLength: 1, reg: fpgp, asm: "MFVSRD", typ: "Int64"}, // move 64 bits of F register into G register
{name: "MTVSRD", argLength: 1, reg: gpfp, asm: "MTVSRD", typ: "Float64"}, // move 64 bits of G register into F register
- {name: "AND", argLength: 2, reg: gp21, asm: "AND", commutative: true}, // arg0&arg1
- {name: "ANDN", argLength: 2, reg: gp21, asm: "ANDN"}, // arg0&^arg1
- {name: "OR", argLength: 2, reg: gp21, asm: "OR", commutative: true}, // arg0|arg1
- {name: "ORN", argLength: 2, reg: gp21, asm: "ORN"}, // arg0|^arg1
- {name: "NOR", argLength: 2, reg: gp21, asm: "NOR", commutative: true}, // ^(arg0|arg1)
- {name: "XOR", argLength: 2, reg: gp21, asm: "XOR", typ: "Int64", commutative: true}, // arg0^arg1
- {name: "EQV", argLength: 2, reg: gp21, asm: "EQV", typ: "Int64", commutative: true}, // arg0^^arg1
- {name: "NEG", argLength: 1, reg: gp11, asm: "NEG"}, // -arg0 (integer)
- {name: "FNEG", argLength: 1, reg: fp11, asm: "FNEG"}, // -arg0 (floating point)
- {name: "FSQRT", argLength: 1, reg: fp11, asm: "FSQRT"}, // sqrt(arg0) (floating point)
- {name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"}, // sqrt(arg0) (floating point, single precision)
- {name: "FFLOOR", argLength: 1, reg: fp11, asm: "FRIM"}, // floor(arg0), float64
- {name: "FCEIL", argLength: 1, reg: fp11, asm: "FRIP"}, // ceil(arg0), float64
- {name: "FTRUNC", argLength: 1, reg: fp11, asm: "FRIZ"}, // trunc(arg0), float64
- {name: "FROUND", argLength: 1, reg: fp11, asm: "FRIN"}, // round(arg0), float64
- {name: "FABS", argLength: 1, reg: fp11, asm: "FABS"}, // abs(arg0), float64
- {name: "FNABS", argLength: 1, reg: fp11, asm: "FNABS"}, // -abs(arg0), float64
- {name: "FCPSGN", argLength: 2, reg: fp21, asm: "FCPSGN"}, // copysign arg0 -> arg1, float64
+ {name: "AND", argLength: 2, reg: gp21, asm: "AND", commutative: true}, // arg0&arg1
+ {name: "ANDN", argLength: 2, reg: gp21, asm: "ANDN"}, // arg0&^arg1
+ {name: "ANDCC", argLength: 2, reg: gp21, asm: "ANDCC", commutative: true, typ: "Flags"}, // arg0&arg1 sets CC
+ {name: "OR", argLength: 2, reg: gp21, asm: "OR", commutative: true}, // arg0|arg1
+ {name: "ORN", argLength: 2, reg: gp21, asm: "ORN"}, // arg0|^arg1
+ {name: "ORCC", argLength: 2, reg: gp21, asm: "ORCC", commutative: true, typ: "Flags"}, // arg0|arg1 sets CC
+ {name: "NOR", argLength: 2, reg: gp21, asm: "NOR", commutative: true}, // ^(arg0|arg1)
+ {name: "XOR", argLength: 2, reg: gp21, asm: "XOR", typ: "Int64", commutative: true}, // arg0^arg1
+ {name: "XORCC", argLength: 2, reg: gp21, asm: "XORCC", commutative: true, typ: "Flags"}, // arg0^arg1 sets CC
+ {name: "EQV", argLength: 2, reg: gp21, asm: "EQV", typ: "Int64", commutative: true}, // arg0^^arg1
+ {name: "NEG", argLength: 1, reg: gp11, asm: "NEG"}, // -arg0 (integer)
+ {name: "FNEG", argLength: 1, reg: fp11, asm: "FNEG"}, // -arg0 (floating point)
+ {name: "FSQRT", argLength: 1, reg: fp11, asm: "FSQRT"}, // sqrt(arg0) (floating point)
+ {name: "FSQRTS", argLength: 1, reg: fp11, asm: "FSQRTS"}, // sqrt(arg0) (floating point, single precision)
+ {name: "FFLOOR", argLength: 1, reg: fp11, asm: "FRIM"}, // floor(arg0), float64
+ {name: "FCEIL", argLength: 1, reg: fp11, asm: "FRIP"}, // ceil(arg0), float64
+ {name: "FTRUNC", argLength: 1, reg: fp11, asm: "FRIZ"}, // trunc(arg0), float64
+ {name: "FROUND", argLength: 1, reg: fp11, asm: "FRIN"}, // round(arg0), float64
+ {name: "FABS", argLength: 1, reg: fp11, asm: "FABS"}, // abs(arg0), float64
+ {name: "FNABS", argLength: 1, reg: fp11, asm: "FNABS"}, // -abs(arg0), float64
+ {name: "FCPSGN", argLength: 2, reg: fp21, asm: "FCPSGN"}, // copysign arg0 -> arg1, float64
{name: "ORconst", argLength: 1, reg: gp11, asm: "OR", aux: "Int64"}, // arg0|aux
{name: "XORconst", argLength: 1, reg: gp11, asm: "XOR", aux: "Int64"}, // arg0^aux
b.Aux = nil
return true
}
+ // match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (EQ (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64EQ
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (EQ (CMPWconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (EQ (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPWconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64EQ
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (EQ (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (EQ (ANDCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64EQ
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (EQ (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (EQ (ORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64EQ
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (EQ (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (EQ (XORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64EQ
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
case BlockPPC64GE:
// match: (GE (FlagEQ) yes no)
// cond:
b.Aux = nil
return true
}
+ // match: (GE (CMPconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (GE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64GE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GE (CMPWconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (GE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPWconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64GE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GE (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GE (ANDCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GE (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GE (ORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GE
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GE (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GE (XORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GE
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
case BlockPPC64GT:
// match: (GT (FlagEQ) yes no)
// cond:
b.Aux = nil
return true
}
+ // match: (GT (CMPconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (GT (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64GT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GT (CMPWconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (GT (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPWconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64GT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GT (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GT (ANDCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GT (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GT (ORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GT
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (GT (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (GT (XORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64GT
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
case BlockIf:
// match: (If (Equal cc) yes no)
// cond:
b.Aux = nil
return true
}
- // match: (If (FGreaterEqual cc) yes no)
- // cond:
- // result: (FGE cc yes no)
+ // match: (If (FGreaterEqual cc) yes no)
+ // cond:
+ // result: (FGE cc yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64FGreaterEqual {
+ break
+ }
+ cc := v.Args[0]
+ b.Kind = BlockPPC64FGE
+ b.SetControl(cc)
+ b.Aux = nil
+ return true
+ }
+ // match: (If cond yes no)
+ // cond:
+ // result: (NE (CMPWconst [0] cond) yes no)
+ for {
+ v := b.Control
+ _ = v
+ cond := b.Control
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64CMPWconst, types.TypeFlags)
+ v0.AuxInt = 0
+ v0.AddArg(cond)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ case BlockPPC64LE:
+ // match: (LE (FlagEQ) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64FlagEQ {
+ break
+ }
+ b.Kind = BlockFirst
+ b.SetControl(nil)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (FlagLT) yes no)
+ // cond:
+ // result: (First nil yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64FlagLT {
+ break
+ }
+ b.Kind = BlockFirst
+ b.SetControl(nil)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (FlagGT) yes no)
+ // cond:
+ // result: (First nil no yes)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64FlagGT {
+ break
+ }
+ b.Kind = BlockFirst
+ b.SetControl(nil)
+ b.Aux = nil
+ b.swapSuccessors()
+ return true
+ }
+ // match: (LE (InvertFlags cmp) yes no)
+ // cond:
+ // result: (GE cmp yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64InvertFlags {
+ break
+ }
+ cmp := v.Args[0]
+ b.Kind = BlockPPC64GE
+ b.SetControl(cmp)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (CMPconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (LE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64LE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (CMPWconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (LE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPWconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64LE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LE (ANDCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (LE (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LE (ORCC x y) yes no)
for {
v := b.Control
- if v.Op != OpPPC64FGreaterEqual {
+ if v.Op != OpPPC64CMPconst {
break
}
- cc := v.Args[0]
- b.Kind = BlockPPC64FGE
- b.SetControl(cc)
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LE
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
b.Aux = nil
return true
}
- // match: (If cond yes no)
- // cond:
- // result: (NE (CMPWconst [0] cond) yes no)
+ // match: (LE (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LE (XORCC x y) yes no)
for {
v := b.Control
- _ = v
- cond := b.Control
- b.Kind = BlockPPC64NE
- v0 := b.NewValue0(v.Pos, OpPPC64CMPWconst, types.TypeFlags)
- v0.AuxInt = 0
- v0.AddArg(cond)
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LE
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
b.SetControl(v0)
b.Aux = nil
return true
}
- case BlockPPC64LE:
- // match: (LE (FlagEQ) yes no)
+ case BlockPPC64LT:
+ // match: (LT (FlagEQ) yes no)
// cond:
- // result: (First nil yes no)
+ // result: (First nil no yes)
for {
v := b.Control
if v.Op != OpPPC64FlagEQ {
b.Kind = BlockFirst
b.SetControl(nil)
b.Aux = nil
+ b.swapSuccessors()
return true
}
- // match: (LE (FlagLT) yes no)
+ // match: (LT (FlagLT) yes no)
// cond:
// result: (First nil yes no)
for {
b.Aux = nil
return true
}
- // match: (LE (FlagGT) yes no)
+ // match: (LT (FlagGT) yes no)
// cond:
// result: (First nil no yes)
for {
b.swapSuccessors()
return true
}
- // match: (LE (InvertFlags cmp) yes no)
+ // match: (LT (InvertFlags cmp) yes no)
// cond:
- // result: (GE cmp yes no)
+ // result: (GT cmp yes no)
for {
v := b.Control
if v.Op != OpPPC64InvertFlags {
break
}
cmp := v.Args[0]
- b.Kind = BlockPPC64GE
+ b.Kind = BlockPPC64GT
b.SetControl(cmp)
b.Aux = nil
return true
}
- case BlockPPC64LT:
- // match: (LT (FlagEQ) yes no)
+ // match: (LT (CMPconst [0] (ANDconst [c] x)) yes no)
// cond:
- // result: (First nil no yes)
+ // result: (LT (ANDCCconst [c] x) yes no)
for {
v := b.Control
- if v.Op != OpPPC64FlagEQ {
+ if v.Op != OpPPC64CMPconst {
break
}
- b.Kind = BlockFirst
- b.SetControl(nil)
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64LT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
b.Aux = nil
- b.swapSuccessors()
return true
}
- // match: (LT (FlagLT) yes no)
+ // match: (LT (CMPWconst [0] (ANDconst [c] x)) yes no)
// cond:
- // result: (First nil yes no)
+ // result: (LT (ANDCCconst [c] x) yes no)
for {
v := b.Control
- if v.Op != OpPPC64FlagLT {
+ if v.Op != OpPPC64CMPWconst {
break
}
- b.Kind = BlockFirst
- b.SetControl(nil)
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64LT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
b.Aux = nil
return true
}
- // match: (LT (FlagGT) yes no)
- // cond:
- // result: (First nil no yes)
+ // match: (LT (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LT (ANDCC x y) yes no)
for {
v := b.Control
- if v.Op != OpPPC64FlagGT {
+ if v.Op != OpPPC64CMPconst {
break
}
- b.Kind = BlockFirst
- b.SetControl(nil)
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LT
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
b.Aux = nil
- b.swapSuccessors()
return true
}
- // match: (LT (InvertFlags cmp) yes no)
- // cond:
- // result: (GT cmp yes no)
+ // match: (LT (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LT (ORCC x y) yes no)
for {
v := b.Control
- if v.Op != OpPPC64InvertFlags {
+ if v.Op != OpPPC64CMPconst {
break
}
- cmp := v.Args[0]
- b.Kind = BlockPPC64GT
- b.SetControl(cmp)
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LT
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (LT (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (LT (XORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64LT
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
b.Aux = nil
return true
}
b.Aux = nil
return true
}
+ // match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (NE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (NE (CMPWconst [0] (ANDconst [c] x)) yes no)
+ // cond:
+ // result: (NE (ANDCCconst [c] x) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPWconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ v_0 := v.Args[0]
+ if v_0.Op != OpPPC64ANDconst {
+ break
+ }
+ c := v_0.AuxInt
+ x := v_0.Args[0]
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCCconst, types.TypeFlags)
+ v0.AuxInt = c
+ v0.AddArg(x)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (NE (CMPconst [0] z:(AND x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (NE (ANDCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64AND {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64ANDCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (NE (CMPconst [0] z:(OR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (NE (ORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64OR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64ORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
+ // match: (NE (CMPconst [0] z:(XOR x y)) yes no)
+ // cond: z.Uses == 1
+ // result: (NE (XORCC x y) yes no)
+ for {
+ v := b.Control
+ if v.Op != OpPPC64CMPconst {
+ break
+ }
+ if v.AuxInt != 0 {
+ break
+ }
+ z := v.Args[0]
+ if z.Op != OpPPC64XOR {
+ break
+ }
+ _ = z.Args[1]
+ x := z.Args[0]
+ y := z.Args[1]
+ if !(z.Uses == 1) {
+ break
+ }
+ b.Kind = BlockPPC64NE
+ v0 := b.NewValue0(v.Pos, OpPPC64XORCC, types.TypeFlags)
+ v0.AddArg(x)
+ v0.AddArg(y)
+ b.SetControl(v0)
+ b.Aux = nil
+ return true
+ }
}
return false
}