var blockJump = map[ssa.BlockKind]struct {
asm, invasm obj.As
}{
- ssa.BlockARM64EQ: {arm64.ABEQ, arm64.ABNE},
- ssa.BlockARM64NE: {arm64.ABNE, arm64.ABEQ},
- ssa.BlockARM64LT: {arm64.ABLT, arm64.ABGE},
- ssa.BlockARM64GE: {arm64.ABGE, arm64.ABLT},
- ssa.BlockARM64LE: {arm64.ABLE, arm64.ABGT},
- ssa.BlockARM64GT: {arm64.ABGT, arm64.ABLE},
- ssa.BlockARM64ULT: {arm64.ABLO, arm64.ABHS},
- ssa.BlockARM64UGE: {arm64.ABHS, arm64.ABLO},
- ssa.BlockARM64UGT: {arm64.ABHI, arm64.ABLS},
- ssa.BlockARM64ULE: {arm64.ABLS, arm64.ABHI},
- ssa.BlockARM64Z: {arm64.ACBZ, arm64.ACBNZ},
- ssa.BlockARM64NZ: {arm64.ACBNZ, arm64.ACBZ},
- ssa.BlockARM64ZW: {arm64.ACBZW, arm64.ACBNZW},
- ssa.BlockARM64NZW: {arm64.ACBNZW, arm64.ACBZW},
+ ssa.BlockARM64EQ: {arm64.ABEQ, arm64.ABNE},
+ ssa.BlockARM64NE: {arm64.ABNE, arm64.ABEQ},
+ ssa.BlockARM64LT: {arm64.ABLT, arm64.ABGE},
+ ssa.BlockARM64GE: {arm64.ABGE, arm64.ABLT},
+ ssa.BlockARM64LE: {arm64.ABLE, arm64.ABGT},
+ ssa.BlockARM64GT: {arm64.ABGT, arm64.ABLE},
+ ssa.BlockARM64ULT: {arm64.ABLO, arm64.ABHS},
+ ssa.BlockARM64UGE: {arm64.ABHS, arm64.ABLO},
+ ssa.BlockARM64UGT: {arm64.ABHI, arm64.ABLS},
+ ssa.BlockARM64ULE: {arm64.ABLS, arm64.ABHI},
+ ssa.BlockARM64Z: {arm64.ACBZ, arm64.ACBNZ},
+ ssa.BlockARM64NZ: {arm64.ACBNZ, arm64.ACBZ},
+ ssa.BlockARM64ZW: {arm64.ACBZW, arm64.ACBNZW},
+ ssa.BlockARM64NZW: {arm64.ACBNZW, arm64.ACBZW},
+ ssa.BlockARM64TBZ: {arm64.ATBZ, arm64.ATBNZ},
+ ssa.BlockARM64TBNZ: {arm64.ATBNZ, arm64.ATBZ},
}
func ssaGenBlock(s *gc.SSAGenState, b, next *ssa.Block) {
p.From.Type = obj.TYPE_REG
p.From.Reg = b.Control.Reg()
}
+ case ssa.BlockARM64TBZ, ssa.BlockARM64TBNZ:
+ jmp := blockJump[b.Kind]
+ var p *obj.Prog
+ switch next {
+ case b.Succs[0].Block():
+ p = s.Prog(jmp.invasm)
+ p.To.Type = obj.TYPE_BRANCH
+ p.From.Offset = b.Aux.(int64)
+ p.From.Type = obj.TYPE_CONST
+ p.Reg = b.Control.Reg()
+ s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[1].Block()})
+ case b.Succs[1].Block():
+ p = s.Prog(jmp.asm)
+ p.To.Type = obj.TYPE_BRANCH
+ p.From.Offset = b.Aux.(int64)
+ p.From.Type = obj.TYPE_CONST
+ p.Reg = b.Control.Reg()
+ s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+ default:
+ p = s.Prog(jmp.asm)
+ p.To.Type = obj.TYPE_BRANCH
+ p.From.Offset = b.Aux.(int64)
+ p.From.Type = obj.TYPE_CONST
+ p.Reg = b.Control.Reg()
+ s.Branches = append(s.Branches, gc.Branch{P: p, B: b.Succs[0].Block()})
+ q := s.Prog(obj.AJMP)
+ q.To.Type = obj.TYPE_BRANCH
+ s.Branches = append(s.Branches, gc.Branch{P: q, B: b.Succs[1].Block()})
+ }
default:
b.Fatalf("branch not implemented: %s. Control: %s", b.LongString(), b.Control.LongString())
(EQ (CMPWconst [0] x) yes no) -> (ZW x yes no)
(NE (CMPWconst [0] x) yes no) -> (NZW x yes no)
+// Absorb bit-tests into block
+(Z (ANDconst [c] x) yes no) && oneBit(c) -> (TBZ {ntz(c)} x yes no)
+(NZ (ANDconst [c] x) yes no) && oneBit(c) -> (TBNZ {ntz(c)} x yes no)
+(ZW (ANDconst [c] x) yes no) && oneBit(int64(uint32(c))) -> (TBZ {ntz(int64(uint32(c)))} x yes no)
+(NZW (ANDconst [c] x) yes no) && oneBit(int64(uint32(c))) -> (TBNZ {ntz(int64(uint32(c)))} x yes no)
+
// fold offset into address
(ADDconst [off1] (MOVDaddr [off2] {sym} ptr)) -> (MOVDaddr [off1+off2] {sym} ptr)
{name: "ULE"},
{name: "UGT"},
{name: "UGE"},
- {name: "Z"}, // Control == 0 (take a register instead of flags)
- {name: "NZ"}, // Control != 0
- {name: "ZW"}, // Control == 0, 32-bit
- {name: "NZW"}, // Control != 0, 32-bit
+ {name: "Z"}, // Control == 0 (take a register instead of flags)
+ {name: "NZ"}, // Control != 0
+ {name: "ZW"}, // Control == 0, 32-bit
+ {name: "NZW"}, // Control != 0, 32-bit
+ {name: "TBZ"}, // Control & (1 << Aux.(int64)) == 0
+ {name: "TBNZ"}, // Control & (1 << Aux.(int64)) != 0
}
archs = append(archs, arch{
fmt.Fprintf(w, "for {\n")
- s := split(match[1 : len(match)-1]) // remove parens, then split
+ _, _, _, aux, s := extract(match) // remove parens, then split
// check match of control value
- if s[1] != "nil" {
+ if s[0] != "nil" {
fmt.Fprintf(w, "v := b.Control\n")
- if strings.Contains(s[1], "(") {
- genMatch0(w, arch, s[1], "v", map[string]struct{}{}, false, rule.loc)
+ if strings.Contains(s[0], "(") {
+ genMatch0(w, arch, s[0], "v", map[string]struct{}{}, false, rule.loc)
} else {
fmt.Fprintf(w, "_ = v\n") // in case we don't use v
- fmt.Fprintf(w, "%s := b.Control\n", s[1])
+ fmt.Fprintf(w, "%s := b.Control\n", s[0])
}
}
+ if aux != "" {
+ fmt.Fprintf(w, "%s := b.Aux\n", aux)
+ }
if cond != "" {
fmt.Fprintf(w, "if !(%s) {\nbreak\n}\n", cond)
}
// Rule matches. Generate result.
- t := split(result[1 : len(result)-1]) // remove parens, then split
- newsuccs := t[2:]
+ outop, _, _, aux, t := extract(result) // remove parens, then split
+ newsuccs := t[1:]
// Check if newsuccs is the same set as succs.
- succs := s[2:]
+ succs := s[1:]
m := map[string]bool{}
for _, succ := range succs {
if m[succ] {
log.Fatalf("unmatched successors %v in %s", m, rule)
}
- fmt.Fprintf(w, "b.Kind = %s\n", blockName(t[0], arch))
- if t[1] == "nil" {
+ fmt.Fprintf(w, "b.Kind = %s\n", blockName(outop, arch))
+ if t[0] == "nil" {
fmt.Fprintf(w, "b.SetControl(nil)\n")
} else {
- fmt.Fprintf(w, "b.SetControl(%s)\n", genResult0(w, arch, t[1], new(int), false, false, rule.loc))
+ fmt.Fprintf(w, "b.SetControl(%s)\n", genResult0(w, arch, t[0], new(int), false, false, rule.loc))
+ }
+ if aux != "" {
+ fmt.Fprintf(w, "b.Aux = %s\n", aux)
+ } else {
+ fmt.Fprintln(w, "b.Aux = nil")
}
succChanged := false
return false
}
-// parseValue parses a parenthesized value from a rule.
-// The value can be from the match or the result side.
-// It returns the op and unparsed strings for typ, auxint, and aux restrictions and for all args.
-// oparch is the architecture that op is located in, or "" for generic.
-func parseValue(val string, arch arch, loc string) (op opData, oparch string, typ string, auxint string, aux string, args []string) {
+func extract(val string) (op string, typ string, auxint string, aux string, args []string) {
val = val[1 : len(val)-1] // remove ()
// Split val up into regions.
s := split(val)
// Extract restrictions and args.
+ op = s[0]
for _, a := range s[1:] {
switch a[0] {
case '<':
args = append(args, a)
}
}
+ return
+}
+
+// parseValue parses a parenthesized value from a rule.
+// The value can be from the match or the result side.
+// It returns the op and unparsed strings for typ, auxint, and aux restrictions and for all args.
+// oparch is the architecture that op is located in, or "" for generic.
+func parseValue(val string, arch arch, loc string) (op opData, oparch string, typ string, auxint string, aux string, args []string) {
// Resolve the op.
+ var s string
+ s, typ, auxint, aux, args = extract(val)
// match reports whether x is a good op to select.
// If strict is true, rule generation might succeed.
// Doing strict=true then strict=false allows
// precise op matching while retaining good error messages.
match := func(x opData, strict bool, archname string) bool {
- if x.name != s[0] {
+ if x.name != s {
return false
}
if x.argLength != -1 && int(x.argLength) != len(args) {
if strict {
return false
} else {
- log.Printf("%s: op %s (%s) should have %d args, has %d", loc, s[0], archname, x.argLength, len(args))
+ log.Printf("%s: op %s (%s) should have %d args, has %d", loc, s, archname, x.argLength, len(args))
}
}
return true
BlockARM64NZ
BlockARM64ZW
BlockARM64NZW
+ BlockARM64TBZ
+ BlockARM64TBNZ
BlockMIPSEQ
BlockMIPSNE
BlockARMUGT: "UGT",
BlockARMUGE: "UGE",
- BlockARM64EQ: "EQ",
- BlockARM64NE: "NE",
- BlockARM64LT: "LT",
- BlockARM64LE: "LE",
- BlockARM64GT: "GT",
- BlockARM64GE: "GE",
- BlockARM64ULT: "ULT",
- BlockARM64ULE: "ULE",
- BlockARM64UGT: "UGT",
- BlockARM64UGE: "UGE",
- BlockARM64Z: "Z",
- BlockARM64NZ: "NZ",
- BlockARM64ZW: "ZW",
- BlockARM64NZW: "NZW",
+ BlockARM64EQ: "EQ",
+ BlockARM64NE: "NE",
+ BlockARM64LT: "LT",
+ BlockARM64LE: "LE",
+ BlockARM64GT: "GT",
+ BlockARM64GE: "GE",
+ BlockARM64ULT: "ULT",
+ BlockARM64ULE: "ULE",
+ BlockARM64UGT: "UGT",
+ BlockARM64UGE: "UGE",
+ BlockARM64Z: "Z",
+ BlockARM64NZ: "NZ",
+ BlockARM64ZW: "ZW",
+ BlockARM64NZW: "NZW",
+ BlockARM64TBZ: "TBZ",
+ BlockARM64TBNZ: "TBNZ",
BlockMIPSEQ: "EQ",
BlockMIPSNE: "NE",
return 64 - nlz(^x&(x-1))
}
+func oneBit(x int64) bool {
+ return nlz(x)+ntz(x) == 63
+}
+
// nlo returns the number of leading ones.
func nlo(x int64) int64 {
return nlz(^x)
cmp := v.Args[0]
b.Kind = Block386EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = Block386LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case Block386GT:
cmp := v.Args[0]
b.Kind = Block386LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockIf:
cmp := v.Args[0]
b.Kind = Block386LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETLE cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETG cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGE cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETEQ cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETNE cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETB cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETBE cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETA cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETAE cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGF cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGEF cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETEQF cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETNEF cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
v0.AddArg(cond)
v0.AddArg(cond)
b.SetControl(v0)
+ b.Aux = nil
return true
}
case Block386LE:
cmp := v.Args[0]
b.Kind = Block386GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = Block386GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = Block386LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no)
}
b.Kind = Block386LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
}
b.Kind = Block386LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
}
b.Kind = Block386LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
}
b.Kind = Block386GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
}
b.Kind = Block386GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
}
b.Kind = Block386GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
}
b.Kind = Block386GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
}
b.Kind = Block386EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
}
b.Kind = Block386EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
}
b.Kind = Block386NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
}
b.Kind = Block386NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
}
b.Kind = Block386ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
}
b.Kind = Block386ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
}
b.Kind = Block386ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
}
b.Kind = Block386ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
}
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
}
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
}
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
}
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
}
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
}
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
}
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
}
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
}
b.Kind = Block386EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
}
b.Kind = Block386EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
}
b.Kind = Block386NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
}
b.Kind = Block386NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = Block386NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case Block386UGE:
cmp := v.Args[0]
b.Kind = Block386ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (UGE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case Block386UGT:
cmp := v.Args[0]
b.Kind = Block386ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (UGT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case Block386ULE:
cmp := v.Args[0]
b.Kind = Block386UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (ULE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = Block386UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (ULT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTL y (SHLL (MOVLconst [1]) x)))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTQ (SHLQ (MOVQconst [1]) x) y))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTQ y (SHLQ (MOVQconst [1]) x)))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTLconst [c] x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTQconst [c] x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTQ (MOVQconst [c]) x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (TESTQ x (MOVQconst [c])))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockAMD64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockAMD64GT:
cmp := v.Args[0]
b.Kind = BlockAMD64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockIf:
cmp := v.Args[0]
b.Kind = BlockAMD64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETLE cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETG cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGE cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETEQ cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETNE cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETB cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETBE cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETA cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETAE cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGF cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETGEF cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETEQF cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (SETNEF cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
v0.AddArg(cond)
v0.AddArg(cond)
b.SetControl(v0)
+ b.Aux = nil
return true
}
case BlockAMD64LE:
cmp := v.Args[0]
b.Kind = BlockAMD64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockAMD64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockAMD64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETL cmp) (SETL cmp)) yes no)
}
b.Kind = BlockAMD64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
}
b.Kind = BlockAMD64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETLE cmp) (SETLE cmp)) yes no)
}
b.Kind = BlockAMD64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
}
b.Kind = BlockAMD64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETG cmp) (SETG cmp)) yes no)
}
b.Kind = BlockAMD64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
}
b.Kind = BlockAMD64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGE cmp) (SETGE cmp)) yes no)
}
b.Kind = BlockAMD64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
}
b.Kind = BlockAMD64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQ cmp) (SETEQ cmp)) yes no)
}
b.Kind = BlockAMD64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
}
b.Kind = BlockAMD64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNE cmp) (SETNE cmp)) yes no)
}
b.Kind = BlockAMD64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
}
b.Kind = BlockAMD64ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETB cmp) (SETB cmp)) yes no)
}
b.Kind = BlockAMD64ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
}
b.Kind = BlockAMD64ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETBE cmp) (SETBE cmp)) yes no)
}
b.Kind = BlockAMD64ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
}
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETA cmp) (SETA cmp)) yes no)
}
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
}
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETAE cmp) (SETAE cmp)) yes no)
}
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTL (SHLL (MOVLconst [1]) x) y))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTL y (SHLL (MOVLconst [1]) x)))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTQ (SHLQ (MOVQconst [1]) x) y))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTQ y (SHLQ (MOVQconst [1]) x)))
v0.AddArg(x)
v0.AddArg(y)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTLconst [c] x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTQconst [c] x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTQ (MOVQconst [c]) x))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTQ x (MOVQconst [c])))
v0.AuxInt = log2(c)
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
}
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGF cmp) (SETGF cmp)) yes no)
}
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
}
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETGEF cmp) (SETGEF cmp)) yes no)
}
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
}
b.Kind = BlockAMD64EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETEQF cmp) (SETEQF cmp)) yes no)
}
b.Kind = BlockAMD64EQF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
}
b.Kind = BlockAMD64NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (TESTB (SETNEF cmp) (SETNEF cmp)) yes no)
}
b.Kind = BlockAMD64NEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockAMD64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockAMD64UGE:
cmp := v.Args[0]
b.Kind = BlockAMD64ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (UGE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockAMD64UGT:
cmp := v.Args[0]
b.Kind = BlockAMD64ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (UGT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockAMD64ULE:
cmp := v.Args[0]
b.Kind = BlockAMD64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (ULE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockAMD64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (ULT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARMEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMGE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARMLE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMGT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARMLT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockIf:
cc := v.Args[0]
b.Kind = BlockARMEQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (NotEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMNE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMLT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMULT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMLE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMULE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMUGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARMUGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
v0.AuxInt = 0
v0.AddArg(cond)
b.SetControl(v0)
+ b.Aux = nil
return true
}
case BlockARMLE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARMGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMLT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARMGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMNE:
cc := v_0.Args[0]
b.Kind = BlockARMEQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (NotEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMNE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (LessThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMLT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (LessThanU cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMULT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (LessEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMLE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (LessEqualU cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMULE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (GreaterThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (GreaterThanU cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMUGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (GreaterEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (GreaterEqualU cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockARMUGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARMNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMUGE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARMULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMUGT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARMULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMULE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARMUGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARMULT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARMUGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
}
x := v.Args[0]
b.Kind = BlockARM64Z
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (CMPWconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockARM64ZW
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARM64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64GE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARM64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64GT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARM64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockIf:
cc := v.Args[0]
b.Kind = BlockARM64EQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (NotEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64NE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64LT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64ULT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64LE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64ULE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64GT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64UGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64GE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64UGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
cond := b.Control
b.Kind = BlockARM64NZ
b.SetControl(cond)
+ b.Aux = nil
return true
}
case BlockARM64LE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARM64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64LT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARM64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64NE:
x := v.Args[0]
b.Kind = BlockARM64NZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockARM64NZW
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARM64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64NZ:
cc := v.Args[0]
b.Kind = BlockARM64EQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (NotEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64NE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (LessThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64LT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (LessThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64ULT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (LessEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64LE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (LessEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64ULE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (GreaterThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64GT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (GreaterThanU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64UGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (GreaterEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64GE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NZ (GreaterEqualU cc) yes no)
cc := v.Args[0]
b.Kind = BlockARM64UGE
b.SetControl(cc)
+ b.Aux = nil
+ return true
+ }
+ // match: (NZ (ANDconst [c] x) yes no)
+ // cond: oneBit(c)
+ // result: (TBNZ {ntz(c)} x yes no)
+ for {
+ v := b.Control
+ if v.Op != OpARM64ANDconst {
+ break
+ }
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(oneBit(c)) {
+ break
+ }
+ b.Kind = BlockARM64TBNZ
+ b.SetControl(x)
+ b.Aux = ntz(c)
return true
}
// match: (NZ (MOVDconst [0]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockARM64NZW:
+ // match: (NZW (ANDconst [c] x) yes no)
+ // cond: oneBit(int64(uint32(c)))
+ // result: (TBNZ {ntz(int64(uint32(c)))} x yes no)
+ for {
+ v := b.Control
+ if v.Op != OpARM64ANDconst {
+ break
+ }
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(oneBit(int64(uint32(c)))) {
+ break
+ }
+ b.Kind = BlockARM64TBNZ
+ b.SetControl(x)
+ b.Aux = ntz(int64(uint32(c)))
+ return true
+ }
// match: (NZW (MOVDconst [c]) yes no)
// cond: int32(c) == 0
// result: (First nil no yes)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockARM64UGE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARM64ULE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64UGT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (FlagGT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (UGT (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockARM64ULT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64ULE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_ULT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULE (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARM64UGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64ULT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagLT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ULT (FlagGT_UGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockARM64UGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockARM64Z:
+ // match: (Z (ANDconst [c] x) yes no)
+ // cond: oneBit(c)
+ // result: (TBZ {ntz(c)} x yes no)
+ for {
+ v := b.Control
+ if v.Op != OpARM64ANDconst {
+ break
+ }
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(oneBit(c)) {
+ break
+ }
+ b.Kind = BlockARM64TBZ
+ b.SetControl(x)
+ b.Aux = ntz(c)
+ return true
+ }
// match: (Z (MOVDconst [0]) yes no)
// cond:
// result: (First nil yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (Z (MOVDconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
case BlockARM64ZW:
+ // match: (ZW (ANDconst [c] x) yes no)
+ // cond: oneBit(int64(uint32(c)))
+ // result: (TBZ {ntz(int64(uint32(c)))} x yes no)
+ for {
+ v := b.Control
+ if v.Op != OpARM64ANDconst {
+ break
+ }
+ c := v.AuxInt
+ x := v.Args[0]
+ if !(oneBit(int64(uint32(c)))) {
+ break
+ }
+ b.Kind = BlockARM64TBZ
+ b.SetControl(x)
+ b.Aux = ntz(int64(uint32(c)))
+ return true
+ }
// match: (ZW (MOVDconst [c]) yes no)
// cond: int32(c) == 0
// result: (First nil yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (ZW (MOVDconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockMIPSFPF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (FPFlagFalse cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockMIPSFPT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGT _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTU _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTconst _)) yes no)
}
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUconst _)) yes no)
}
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTzero _)) yes no)
}
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUzero _)) yes no)
}
b.Kind = BlockMIPSNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (SGTUconst [1] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSNE
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGTUzero x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSEQ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGTconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSGEZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGTzero x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSLEZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (MOVWconst [0]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (MOVWconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GEZ (MOVWconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GTZ (MOVWconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cond := b.Control
b.Kind = BlockMIPSNE
b.SetControl(cond)
+ b.Aux = nil
return true
}
case BlockMIPSLEZ:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LEZ (MOVWconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LTZ (MOVWconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockMIPSFPT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (FPFlagFalse cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockMIPSFPF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGT _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTU _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTconst _)) yes no)
}
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTUconst _)) yes no)
}
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTzero _)) yes no)
}
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTUzero _)) yes no)
}
b.Kind = BlockMIPSEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (SGTUconst [1] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSEQ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGTUzero x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSNE
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGTconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSLTZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGTzero x) yes no)
x := v.Args[0]
b.Kind = BlockMIPSGTZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (MOVWconst [0]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
}
cmp := v.Args[0]
b.Kind = BlockMIPS64FPF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (FPFlagFalse cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockMIPS64FPT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGT _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPS64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTU _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPS64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTconst _)) yes no)
}
b.Kind = BlockMIPS64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (XORconst [1] cmp:(SGTUconst _)) yes no)
}
b.Kind = BlockMIPS64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (SGTUconst [1] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPS64NE
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGTU x (MOVVconst [0])) yes no)
}
b.Kind = BlockMIPS64EQ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGTconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPS64GEZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (SGT x (MOVVconst [0])) yes no)
}
b.Kind = BlockMIPS64LEZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (EQ (MOVVconst [0]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (MOVVconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GEZ (MOVVconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GTZ (MOVVconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cond := b.Control
b.Kind = BlockMIPS64NE
b.SetControl(cond)
+ b.Aux = nil
return true
}
case BlockMIPS64LEZ:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LEZ (MOVVconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LTZ (MOVVconst [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockMIPS64FPT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (FPFlagFalse cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockMIPS64FPF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGT _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPS64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTU _ _)) yes no)
_ = cmp.Args[1]
b.Kind = BlockMIPS64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTconst _)) yes no)
}
b.Kind = BlockMIPS64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (XORconst [1] cmp:(SGTUconst _)) yes no)
}
b.Kind = BlockMIPS64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (SGTUconst [1] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPS64EQ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGTU x (MOVVconst [0])) yes no)
}
b.Kind = BlockMIPS64NE
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGTconst [0] x) yes no)
x := v.Args[0]
b.Kind = BlockMIPS64LTZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (SGT x (MOVVconst [0])) yes no)
}
b.Kind = BlockMIPS64GTZ
b.SetControl(x)
+ b.Aux = nil
return true
}
// match: (NE (MOVVconst [0]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
}
v0.AuxInt = c
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (CMPWconst [0] (ANDconst [c] x)) yes no)
v0.AuxInt = c
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (EQ (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockPPC64EQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockPPC64GE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockPPC64LE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockPPC64GT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GT (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockPPC64LT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockIf:
cc := v.Args[0]
b.Kind = BlockPPC64EQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (NotEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64NE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64LT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (LessEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64LE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64GT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (GreaterEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64GE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (FLessThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64FLT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (FLessEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64FLE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (FGreaterThan cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64FGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If (FGreaterEqual cc) yes no)
cc := v.Args[0]
b.Kind = BlockPPC64FGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
v0.AuxInt = 0
v0.AddArg(cond)
b.SetControl(v0)
+ b.Aux = nil
return true
}
case BlockPPC64LE:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockPPC64GE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockPPC64LT:
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockPPC64GT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
case BlockPPC64NE:
cc := v_0.Args[0]
b.Kind = BlockPPC64EQ
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (NotEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64NE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (LessThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64LT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (LessEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64LE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (GreaterThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64GT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (GreaterEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64GE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (FLessThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64FLT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (FLessEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64FLE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (FGreaterThan cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64FGT
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (FGreaterEqual cc)) yes no)
cc := v_0.Args[0]
b.Kind = BlockPPC64FGE
b.SetControl(cc)
+ b.Aux = nil
return true
}
// match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
v0.AuxInt = c
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (ANDconst [c] x)) yes no)
v0.AuxInt = c
v0.AddArg(x)
b.SetControl(v0)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockPPC64NE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
}
cmp := v.Args[0]
b.Kind = BlockS390XEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (EQ (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (EQ (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockS390XLE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (GE (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockS390XGT:
cmp := v.Args[0]
b.Kind = BlockS390XLT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (GT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
case BlockIf:
cmp := v.Args[2]
b.Kind = BlockS390XLT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XLE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XGTF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp) yes no)
cmp := v.Args[2]
b.Kind = BlockS390XGEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (If cond yes no)
v1.AddArg(cond)
v0.AddArg(v1)
b.SetControl(v0)
+ b.Aux = nil
return true
}
case BlockS390XLE:
cmp := v.Args[0]
b.Kind = BlockS390XGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagLT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LE (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v.Args[0]
b.Kind = BlockS390XGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (LT (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (LT (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
cmp := v_0.Args[2]
b.Kind = BlockS390XLT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDLE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XLE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDGT (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XGT
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDGE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XGE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDEQ (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XEQ
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDNE (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDGTnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XGTF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (CMPWconst [0] (MOVDGEnoinv (MOVDconst [0]) (MOVDconst [1]) cmp)) yes no)
cmp := v_0.Args[2]
b.Kind = BlockS390XGEF
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (InvertFlags cmp) yes no)
cmp := v.Args[0]
b.Kind = BlockS390XNE
b.SetControl(cmp)
+ b.Aux = nil
return true
}
// match: (NE (FlagEQ) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (NE (FlagGT) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
}
cond := v.Args[0]
b.Kind = BlockIf
b.SetControl(cond)
+ b.Aux = nil
b.swapSuccessors()
return true
}
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
return true
}
// match: (If (ConstBool [c]) yes no)
}
b.Kind = BlockFirst
b.SetControl(nil)
+ b.Aux = nil
b.swapSuccessors()
return true
}