// comparison simplification
(CMP x (RSBconst [0] y)) -> (CMN x y)
(CMN x (RSBconst [0] y)) -> (CMP x y)
-(EQ (CMPconst [0] (SUB x y)) yes no) -> (EQ (CMP x y) yes no)
-(EQ (CMPconst [0] (MULS x y a)) yes no) -> (EQ (CMP a (MUL <x.Type> x y)) yes no)
-(EQ (CMPconst [0] (SUBconst [c] x)) yes no) -> (EQ (CMPconst [c] x) yes no)
-(EQ (CMPconst [0] (SUBshiftLL x y [c])) yes no) -> (EQ (CMPshiftLL x y [c]) yes no)
-(EQ (CMPconst [0] (SUBshiftRL x y [c])) yes no) -> (EQ (CMPshiftRL x y [c]) yes no)
-(EQ (CMPconst [0] (SUBshiftRA x y [c])) yes no) -> (EQ (CMPshiftRA x y [c]) yes no)
-(EQ (CMPconst [0] (SUBshiftLLreg x y z)) yes no) -> (EQ (CMPshiftLLreg x y z) yes no)
-(EQ (CMPconst [0] (SUBshiftRLreg x y z)) yes no) -> (EQ (CMPshiftRLreg x y z) yes no)
-(EQ (CMPconst [0] (SUBshiftRAreg x y z)) yes no) -> (EQ (CMPshiftRAreg x y z) yes no)
-(NE (CMPconst [0] (SUB x y)) yes no) -> (NE (CMP x y) yes no)
-(NE (CMPconst [0] (MULS x y a)) yes no) -> (NE (CMP a (MUL <x.Type> x y)) yes no)
-(NE (CMPconst [0] (SUBconst [c] x)) yes no) -> (NE (CMPconst [c] x) yes no)
-(NE (CMPconst [0] (SUBshiftLL x y [c])) yes no) -> (NE (CMPshiftLL x y [c]) yes no)
-(NE (CMPconst [0] (SUBshiftRL x y [c])) yes no) -> (NE (CMPshiftRL x y [c]) yes no)
-(NE (CMPconst [0] (SUBshiftRA x y [c])) yes no) -> (NE (CMPshiftRA x y [c]) yes no)
-(NE (CMPconst [0] (SUBshiftLLreg x y z)) yes no) -> (NE (CMPshiftLLreg x y z) yes no)
-(NE (CMPconst [0] (SUBshiftRLreg x y z)) yes no) -> (NE (CMPshiftRLreg x y z) yes no)
-(NE (CMPconst [0] (SUBshiftRAreg x y z)) yes no) -> (NE (CMPshiftRAreg x y z) yes no)
-(EQ (CMPconst [0] (ADD x y)) yes no) -> (EQ (CMN x y) yes no)
-(EQ (CMPconst [0] (MULA x y a)) yes no) -> (EQ (CMN a (MUL <x.Type> x y)) yes no)
-(EQ (CMPconst [0] (ADDconst [c] x)) yes no) -> (EQ (CMNconst [c] x) yes no)
-(EQ (CMPconst [0] (ADDshiftLL x y [c])) yes no) -> (EQ (CMNshiftLL x y [c]) yes no)
-(EQ (CMPconst [0] (ADDshiftRL x y [c])) yes no) -> (EQ (CMNshiftRL x y [c]) yes no)
-(EQ (CMPconst [0] (ADDshiftRA x y [c])) yes no) -> (EQ (CMNshiftRA x y [c]) yes no)
-(EQ (CMPconst [0] (ADDshiftLLreg x y z)) yes no) -> (EQ (CMNshiftLLreg x y z) yes no)
-(EQ (CMPconst [0] (ADDshiftRLreg x y z)) yes no) -> (EQ (CMNshiftRLreg x y z) yes no)
-(EQ (CMPconst [0] (ADDshiftRAreg x y z)) yes no) -> (EQ (CMNshiftRAreg x y z) yes no)
-(NE (CMPconst [0] (ADD x y)) yes no) -> (NE (CMN x y) yes no)
-(NE (CMPconst [0] (MULA x y a)) yes no) -> (NE (CMN a (MUL <x.Type> x y)) yes no)
-(NE (CMPconst [0] (ADDconst [c] x)) yes no) -> (NE (CMNconst [c] x) yes no)
-(NE (CMPconst [0] (ADDshiftLL x y [c])) yes no) -> (NE (CMNshiftLL x y [c]) yes no)
-(NE (CMPconst [0] (ADDshiftRL x y [c])) yes no) -> (NE (CMNshiftRL x y [c]) yes no)
-(NE (CMPconst [0] (ADDshiftRA x y [c])) yes no) -> (NE (CMNshiftRA x y [c]) yes no)
-(NE (CMPconst [0] (ADDshiftLLreg x y z)) yes no) -> (NE (CMNshiftLLreg x y z) yes no)
-(NE (CMPconst [0] (ADDshiftRLreg x y z)) yes no) -> (NE (CMNshiftRLreg x y z) yes no)
-(NE (CMPconst [0] (ADDshiftRAreg x y z)) yes no) -> (NE (CMNshiftRAreg x y z) yes no)
-(EQ (CMPconst [0] (AND x y)) yes no) -> (EQ (TST x y) yes no)
-(EQ (CMPconst [0] (ANDconst [c] x)) yes no) -> (EQ (TSTconst [c] x) yes no)
-(EQ (CMPconst [0] (ANDshiftLL x y [c])) yes no) -> (EQ (TSTshiftLL x y [c]) yes no)
-(EQ (CMPconst [0] (ANDshiftRL x y [c])) yes no) -> (EQ (TSTshiftRL x y [c]) yes no)
-(EQ (CMPconst [0] (ANDshiftRA x y [c])) yes no) -> (EQ (TSTshiftRA x y [c]) yes no)
-(EQ (CMPconst [0] (ANDshiftLLreg x y z)) yes no) -> (EQ (TSTshiftLLreg x y z) yes no)
-(EQ (CMPconst [0] (ANDshiftRLreg x y z)) yes no) -> (EQ (TSTshiftRLreg x y z) yes no)
-(EQ (CMPconst [0] (ANDshiftRAreg x y z)) yes no) -> (EQ (TSTshiftRAreg x y z) yes no)
-(NE (CMPconst [0] (AND x y)) yes no) -> (NE (TST x y) yes no)
-(NE (CMPconst [0] (ANDconst [c] x)) yes no) -> (NE (TSTconst [c] x) yes no)
-(NE (CMPconst [0] (ANDshiftLL x y [c])) yes no) -> (NE (TSTshiftLL x y [c]) yes no)
-(NE (CMPconst [0] (ANDshiftRL x y [c])) yes no) -> (NE (TSTshiftRL x y [c]) yes no)
-(NE (CMPconst [0] (ANDshiftRA x y [c])) yes no) -> (NE (TSTshiftRA x y [c]) yes no)
-(NE (CMPconst [0] (ANDshiftLLreg x y z)) yes no) -> (NE (TSTshiftLLreg x y z) yes no)
-(NE (CMPconst [0] (ANDshiftRLreg x y z)) yes no) -> (NE (TSTshiftRLreg x y z) yes no)
-(NE (CMPconst [0] (ANDshiftRAreg x y z)) yes no) -> (NE (TSTshiftRAreg x y z) yes no)
-(EQ (CMPconst [0] (XOR x y)) yes no) -> (EQ (TEQ x y) yes no)
-(EQ (CMPconst [0] (XORconst [c] x)) yes no) -> (EQ (TEQconst [c] x) yes no)
-(EQ (CMPconst [0] (XORshiftLL x y [c])) yes no) -> (EQ (TEQshiftLL x y [c]) yes no)
-(EQ (CMPconst [0] (XORshiftRL x y [c])) yes no) -> (EQ (TEQshiftRL x y [c]) yes no)
-(EQ (CMPconst [0] (XORshiftRA x y [c])) yes no) -> (EQ (TEQshiftRA x y [c]) yes no)
-(EQ (CMPconst [0] (XORshiftLLreg x y z)) yes no) -> (EQ (TEQshiftLLreg x y z) yes no)
-(EQ (CMPconst [0] (XORshiftRLreg x y z)) yes no) -> (EQ (TEQshiftRLreg x y z) yes no)
-(EQ (CMPconst [0] (XORshiftRAreg x y z)) yes no) -> (EQ (TEQshiftRAreg x y z) yes no)
-(NE (CMPconst [0] (XOR x y)) yes no) -> (NE (TEQ x y) yes no)
-(NE (CMPconst [0] (XORconst [c] x)) yes no) -> (NE (TEQconst [c] x) yes no)
-(NE (CMPconst [0] (XORshiftLL x y [c])) yes no) -> (NE (TEQshiftLL x y [c]) yes no)
-(NE (CMPconst [0] (XORshiftRL x y [c])) yes no) -> (NE (TEQshiftRL x y [c]) yes no)
-(NE (CMPconst [0] (XORshiftRA x y [c])) yes no) -> (NE (TEQshiftRA x y [c]) yes no)
-(NE (CMPconst [0] (XORshiftLLreg x y z)) yes no) -> (NE (TEQshiftLLreg x y z) yes no)
-(NE (CMPconst [0] (XORshiftRLreg x y z)) yes no) -> (NE (TEQshiftRLreg x y z) yes no)
-(NE (CMPconst [0] (XORshiftRAreg x y z)) yes no) -> (NE (TEQshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(SUB x y)) yes no) -> (LT (CMP x y) yes no)
-(LT (CMPconst [0] (MULS x y a)) yes no) -> (LT (CMP a (MUL <x.Type> x y)) yes no)
-(LT (CMPconst [0] l:(SUBconst [c] x)) yes no) -> (LT (CMPconst [c] x) yes no)
-(LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) -> (LT (CMPshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) -> (LT (CMPshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) -> (LT (CMPshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) -> (LT (CMPshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) -> (LT (CMPshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) -> (LT (CMPshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(SUB x y)) yes no) -> (LE (CMP x y) yes no)
-(LE (CMPconst [0] (MULS x y a)) yes no) -> (LE (CMP a (MUL <x.Type> x y)) yes no)
-(LE (CMPconst [0] l:(SUBconst [c] x)) yes no) -> (LE (CMPconst [c] x) yes no)
-(LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) -> (LE (CMPshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) -> (LE (CMPshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) -> (LE (CMPshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) -> (LE (CMPshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) -> (LE (CMPshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) -> (LE (CMPshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(ADD x y)) yes no) -> (LT (CMN x y) yes no)
-(LT (CMPconst [0] (MULA x y a)) yes no) -> (LT (CMN a (MUL <x.Type> x y)) yes no)
-(LT (CMPconst [0] l:(ADDconst [c] x)) yes no) -> (LT (CMNconst [c] x) yes no)
-(LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) -> (LT (CMNshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) -> (LT (CMNshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) -> (LT (CMNshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) -> (LT (CMNshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) -> (LT (CMNshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) -> (LT (CMNshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(ADD x y)) yes no) -> (LE (CMN x y) yes no)
-(LE (CMPconst [0] (MULA x y a)) yes no) -> (LE (CMN a (MUL <x.Type> x y)) yes no)
-(LE (CMPconst [0] l:(ADDconst [c] x)) yes no) -> (LE (CMNconst [c] x) yes no)
-(LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) -> (LE (CMNshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) -> (LE (CMNshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) -> (LE (CMNshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) -> (LE (CMNshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) -> (LE (CMNshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) -> (LE (CMNshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(AND x y)) yes no) -> (LT (TST x y) yes no)
-(LT (CMPconst [0] l:(ANDconst [c] x)) yes no) -> (LT (TSTconst [c] x) yes no)
-(LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) -> (LT (TSTshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) -> (LT (TSTshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) -> (LT (TSTshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) -> (LT (TSTshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) -> (LT (TSTshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) -> (LT (TSTshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(AND x y)) yes no) -> (LE (TST x y) yes no)
-(LE (CMPconst [0] l:(ANDconst [c] x)) yes no) -> (LE (TSTconst [c] x) yes no)
-(LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) -> (LE (TSTshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) -> (LE (TSTshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) -> (LE (TSTshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) -> (LE (TSTshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) -> (LE (TSTshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) -> (LE (TSTshiftRAreg x y z) yes no)
-(LT (CMPconst [0] l:(XOR x y)) yes no) -> (LT (TEQ x y) yes no)
-(LT (CMPconst [0] l:(XORconst [c] x)) yes no) -> (LT (TEQconst [c] x) yes no)
-(LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) -> (LT (TEQshiftLL x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) -> (LT (TEQshiftRL x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) -> (LT (TEQshiftRA x y [c]) yes no)
-(LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) -> (LT (TEQshiftLLreg x y z) yes no)
-(LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) -> (LT (TEQshiftRLreg x y z) yes no)
-(LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) -> (LT (TEQshiftRAreg x y z) yes no)
-(LE (CMPconst [0] l:(XOR x y)) yes no) -> (LE (TEQ x y) yes no)
-(LE (CMPconst [0] l:(XORconst [c] x)) yes no) -> (LE (TEQconst [c] x) yes no)
-(LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) -> (LE (TEQshiftLL x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) -> (LE (TEQshiftRL x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) -> (LE (TEQshiftRA x y [c]) yes no)
-(LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) -> (LE (TEQshiftLLreg x y z) yes no)
-(LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) -> (LE (TEQshiftRLreg x y z) yes no)
-(LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) -> (LE (TEQshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(SUB x y)) yes no) -> (GT (CMP x y) yes no)
-(GT (CMPconst [0] (MULS x y a)) yes no) -> (GT (CMP a (MUL <x.Type> x y)) yes no)
-(GT (CMPconst [0] l:(SUBconst [c] x)) yes no) -> (GT (CMPconst [c] x) yes no)
-(GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) -> (GT (CMPshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) -> (GT (CMPshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) -> (GT (CMPshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) -> (GT (CMPshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) -> (GT (CMPshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) -> (GT (CMPshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(SUB x y)) yes no) -> (GE (CMP x y) yes no)
-(GE (CMPconst [0] (MULS x y a)) yes no) -> (GE (CMP a (MUL <x.Type> x y)) yes no)
-(GE (CMPconst [0] l:(SUBconst [c] x)) yes no) -> (GE (CMPconst [c] x) yes no)
-(GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) -> (GE (CMPshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) -> (GE (CMPshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) -> (GE (CMPshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) -> (GE (CMPshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) -> (GE (CMPshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) -> (GE (CMPshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(ADD x y)) yes no) -> (GT (CMN x y) yes no)
-(GT (CMPconst [0] l:(ADDconst [c] x)) yes no) -> (GT (CMNconst [c] x) yes no)
-(GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) -> (GT (CMNshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) -> (GT (CMNshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) -> (GT (CMNshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) -> (GT (CMNshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) -> (GT (CMNshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) -> (GT (CMNshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(ADD x y)) yes no) -> (GE (CMN x y) yes no)
-(GE (CMPconst [0] (MULA x y a)) yes no) -> (GE (CMN a (MUL <x.Type> x y)) yes no)
-(GE (CMPconst [0] l:(ADDconst [c] x)) yes no) -> (GE (CMNconst [c] x) yes no)
-(GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) -> (GE (CMNshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) -> (GE (CMNshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) -> (GE (CMNshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) -> (GE (CMNshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) -> (GE (CMNshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) -> (GE (CMNshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(AND x y)) yes no) -> (GT (TST x y) yes no)
-(GT (CMPconst [0] (MULA x y a)) yes no) -> (GT (CMN a (MUL <x.Type> x y)) yes no)
-(GT (CMPconst [0] l:(ANDconst [c] x)) yes no) -> (GT (TSTconst [c] x) yes no)
-(GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) -> (GT (TSTshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) -> (GT (TSTshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) -> (GT (TSTshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) -> (GT (TSTshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) -> (GT (TSTshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) -> (GT (TSTshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(AND x y)) yes no) -> (GE (TST x y) yes no)
-(GE (CMPconst [0] l:(ANDconst [c] x)) yes no) -> (GE (TSTconst [c] x) yes no)
-(GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) -> (GE (TSTshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) -> (GE (TSTshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) -> (GE (TSTshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) -> (GE (TSTshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) -> (GE (TSTshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) -> (GE (TSTshiftRAreg x y z) yes no)
-(GT (CMPconst [0] l:(XOR x y)) yes no) -> (GT (TEQ x y) yes no)
-(GT (CMPconst [0] l:(XORconst [c] x)) yes no) -> (GT (TEQconst [c] x) yes no)
-(GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) -> (GT (TEQshiftLL x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) -> (GT (TEQshiftRL x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) -> (GT (TEQshiftRA x y [c]) yes no)
-(GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) -> (GT (TEQshiftLLreg x y z) yes no)
-(GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) -> (GT (TEQshiftRLreg x y z) yes no)
-(GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) -> (GT (TEQshiftRAreg x y z) yes no)
-(GE (CMPconst [0] l:(XOR x y)) yes no) -> (GE (TEQ x y) yes no)
-(GE (CMPconst [0] l:(XORconst [c] x)) yes no) -> (GE (TEQconst [c] x) yes no)
-(GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) -> (GE (TEQshiftLL x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) -> (GE (TEQshiftRL x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) -> (GE (TEQshiftRA x y [c]) yes no)
-(GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) -> (GE (TEQshiftLLreg x y z) yes no)
-(GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) -> (GE (TEQshiftRLreg x y z) yes no)
-(GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) -> (GE (TEQshiftRAreg x y z) yes no)
+(EQ (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (EQ (CMP x y) yes no)
+(EQ (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (EQ (CMP a (MUL <x.Type> x y)) yes no)
+(EQ (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (EQ (CMPconst [c] x) yes no)
+(EQ (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (EQ (CMPshiftLL x y [c]) yes no)
+(EQ (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (EQ (CMPshiftRL x y [c]) yes no)
+(EQ (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (EQ (CMPshiftRA x y [c]) yes no)
+(EQ (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (EQ (CMPshiftLLreg x y z) yes no)
+(EQ (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (EQ (CMPshiftRLreg x y z) yes no)
+(EQ (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (EQ (CMPshiftRAreg x y z) yes no)
+(NE (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (NE (CMP x y) yes no)
+(NE (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (NE (CMP a (MUL <x.Type> x y)) yes no)
+(NE (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (NE (CMPconst [c] x) yes no)
+(NE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (NE (CMPshiftLL x y [c]) yes no)
+(NE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (NE (CMPshiftRL x y [c]) yes no)
+(NE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (NE (CMPshiftRA x y [c]) yes no)
+(NE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (NE (CMPshiftLLreg x y z) yes no)
+(NE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (NE (CMPshiftRLreg x y z) yes no)
+(NE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (NE (CMPshiftRAreg x y z) yes no)
+(EQ (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (EQ (CMN x y) yes no)
+(EQ (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (EQ (CMN a (MUL <x.Type> x y)) yes no)
+(EQ (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (EQ (CMNconst [c] x) yes no)
+(EQ (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (EQ (CMNshiftLL x y [c]) yes no)
+(EQ (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (EQ (CMNshiftRL x y [c]) yes no)
+(EQ (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (EQ (CMNshiftRA x y [c]) yes no)
+(EQ (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (EQ (CMNshiftLLreg x y z) yes no)
+(EQ (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (EQ (CMNshiftRLreg x y z) yes no)
+(EQ (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (EQ (CMNshiftRAreg x y z) yes no)
+(NE (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (NE (CMN x y) yes no)
+(NE (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (NE (CMN a (MUL <x.Type> x y)) yes no)
+(NE (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (NE (CMNconst [c] x) yes no)
+(NE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (NE (CMNshiftLL x y [c]) yes no)
+(NE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (NE (CMNshiftRL x y [c]) yes no)
+(NE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (NE (CMNshiftRA x y [c]) yes no)
+(NE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (NE (CMNshiftLLreg x y z) yes no)
+(NE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (NE (CMNshiftRLreg x y z) yes no)
+(NE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (NE (CMNshiftRAreg x y z) yes no)
+(EQ (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (EQ (TST x y) yes no)
+(EQ (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (EQ (TSTconst [c] x) yes no)
+(EQ (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (EQ (TSTshiftLL x y [c]) yes no)
+(EQ (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (EQ (TSTshiftRL x y [c]) yes no)
+(EQ (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (EQ (TSTshiftRA x y [c]) yes no)
+(EQ (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (EQ (TSTshiftLLreg x y z) yes no)
+(EQ (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (EQ (TSTshiftRLreg x y z) yes no)
+(EQ (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (EQ (TSTshiftRAreg x y z) yes no)
+(NE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (NE (TST x y) yes no)
+(NE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (NE (TSTconst [c] x) yes no)
+(NE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (NE (TSTshiftLL x y [c]) yes no)
+(NE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (NE (TSTshiftRL x y [c]) yes no)
+(NE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (NE (TSTshiftRA x y [c]) yes no)
+(NE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (NE (TSTshiftLLreg x y z) yes no)
+(NE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (NE (TSTshiftRLreg x y z) yes no)
+(NE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (NE (TSTshiftRAreg x y z) yes no)
+(EQ (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (EQ (TEQ x y) yes no)
+(EQ (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (EQ (TEQconst [c] x) yes no)
+(EQ (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (EQ (TEQshiftLL x y [c]) yes no)
+(EQ (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (EQ (TEQshiftRL x y [c]) yes no)
+(EQ (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (EQ (TEQshiftRA x y [c]) yes no)
+(EQ (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (EQ (TEQshiftLLreg x y z) yes no)
+(EQ (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (EQ (TEQshiftRLreg x y z) yes no)
+(EQ (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (EQ (TEQshiftRAreg x y z) yes no)
+(NE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (NE (TEQ x y) yes no)
+(NE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (NE (TEQconst [c] x) yes no)
+(NE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (NE (TEQshiftLL x y [c]) yes no)
+(NE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (NE (TEQshiftRL x y [c]) yes no)
+(NE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (NE (TEQshiftRA x y [c]) yes no)
+(NE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (NE (TEQshiftLLreg x y z) yes no)
+(NE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (NE (TEQshiftRLreg x y z) yes no)
+(NE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (NE (TEQshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (LT (CMP x y) yes no)
+(LT (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (LT (CMP a (MUL <x.Type> x y)) yes no)
+(LT (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (LT (CMPconst [c] x) yes no)
+(LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (LT (CMPshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (LT (CMPshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (LT (CMPshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (LT (CMPshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (LT (CMPshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (LT (CMPshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (LE (CMP x y) yes no)
+(LE (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (LE (CMP a (MUL <x.Type> x y)) yes no)
+(LE (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (LE (CMPconst [c] x) yes no)
+(LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (LE (CMPshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (LE (CMPshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (LE (CMPshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (LE (CMPshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (LE (CMPshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (LE (CMPshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (LT (CMN x y) yes no)
+(LT (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (LT (CMN a (MUL <x.Type> x y)) yes no)
+(LT (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (LT (CMNconst [c] x) yes no)
+(LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (LT (CMNshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (LT (CMNshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (LT (CMNshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (LT (CMNshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (LT (CMNshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (LT (CMNshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (LE (CMN x y) yes no)
+(LE (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (LE (CMN a (MUL <x.Type> x y)) yes no)
+(LE (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (LE (CMNconst [c] x) yes no)
+(LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (LE (CMNshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (LE (CMNshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (LE (CMNshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (LE (CMNshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (LE (CMNshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (LE (CMNshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (LT (TST x y) yes no)
+(LT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (LT (TSTconst [c] x) yes no)
+(LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (LT (TSTshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (LT (TSTshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (LT (TSTshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (LT (TSTshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (LT (TSTshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (LT (TSTshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (LE (TST x y) yes no)
+(LE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (LE (TSTconst [c] x) yes no)
+(LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (LE (TSTshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (LE (TSTshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (LE (TSTshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (LE (TSTshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (LE (TSTshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (LE (TSTshiftRAreg x y z) yes no)
+(LT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (LT (TEQ x y) yes no)
+(LT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (LT (TEQconst [c] x) yes no)
+(LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (LT (TEQshiftLL x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (LT (TEQshiftRL x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (LT (TEQshiftRA x y [c]) yes no)
+(LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (LT (TEQshiftLLreg x y z) yes no)
+(LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (LT (TEQshiftRLreg x y z) yes no)
+(LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (LT (TEQshiftRAreg x y z) yes no)
+(LE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (LE (TEQ x y) yes no)
+(LE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (LE (TEQconst [c] x) yes no)
+(LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (LE (TEQshiftLL x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (LE (TEQshiftRL x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (LE (TEQshiftRA x y [c]) yes no)
+(LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (LE (TEQshiftLLreg x y z) yes no)
+(LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (LE (TEQshiftRLreg x y z) yes no)
+(LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (LE (TEQshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (GT (CMP x y) yes no)
+(GT (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (GT (CMP a (MUL <x.Type> x y)) yes no)
+(GT (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (GT (CMPconst [c] x) yes no)
+(GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (GT (CMPshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (GT (CMPshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (GT (CMPshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (GT (CMPshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (GT (CMPshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (GT (CMPshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(SUB x y)) yes no) && l.Uses==1 -> (GE (CMP x y) yes no)
+(GE (CMPconst [0] l:(MULS x y a)) yes no) && l.Uses==1 -> (GE (CMP a (MUL <x.Type> x y)) yes no)
+(GE (CMPconst [0] l:(SUBconst [c] x)) yes no) && l.Uses==1 -> (GE (CMPconst [c] x) yes no)
+(GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no) && l.Uses==1 -> (GE (CMPshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no) && l.Uses==1 -> (GE (CMPshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no) && l.Uses==1 -> (GE (CMPshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no) && l.Uses==1 -> (GE (CMPshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no) && l.Uses==1 -> (GE (CMPshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no) && l.Uses==1 -> (GE (CMPshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (GT (CMN x y) yes no)
+(GT (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (GT (CMNconst [c] x) yes no)
+(GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (GT (CMNshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (GT (CMNshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (GT (CMNshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (GT (CMNshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (GT (CMNshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (GT (CMNshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(ADD x y)) yes no) && l.Uses==1 -> (GE (CMN x y) yes no)
+(GE (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (GE (CMN a (MUL <x.Type> x y)) yes no)
+(GE (CMPconst [0] l:(ADDconst [c] x)) yes no) && l.Uses==1 -> (GE (CMNconst [c] x) yes no)
+(GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no) && l.Uses==1 -> (GE (CMNshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no) && l.Uses==1 -> (GE (CMNshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no) && l.Uses==1 -> (GE (CMNshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no) && l.Uses==1 -> (GE (CMNshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no) && l.Uses==1 -> (GE (CMNshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no) && l.Uses==1 -> (GE (CMNshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (GT (TST x y) yes no)
+(GT (CMPconst [0] l:(MULA x y a)) yes no) && l.Uses==1 -> (GT (CMN a (MUL <x.Type> x y)) yes no)
+(GT (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (GT (TSTconst [c] x) yes no)
+(GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (GT (TSTshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (GT (TSTshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (GT (TSTshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (GT (TSTshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (GT (TSTshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (GT (TSTshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(AND x y)) yes no) && l.Uses==1 -> (GE (TST x y) yes no)
+(GE (CMPconst [0] l:(ANDconst [c] x)) yes no) && l.Uses==1 -> (GE (TSTconst [c] x) yes no)
+(GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no) && l.Uses==1 -> (GE (TSTshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no) && l.Uses==1 -> (GE (TSTshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no) && l.Uses==1 -> (GE (TSTshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no) && l.Uses==1 -> (GE (TSTshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no) && l.Uses==1 -> (GE (TSTshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no) && l.Uses==1 -> (GE (TSTshiftRAreg x y z) yes no)
+(GT (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (GT (TEQ x y) yes no)
+(GT (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (GT (TEQconst [c] x) yes no)
+(GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (GT (TEQshiftLL x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (GT (TEQshiftRL x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (GT (TEQshiftRA x y [c]) yes no)
+(GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (GT (TEQshiftLLreg x y z) yes no)
+(GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (GT (TEQshiftRLreg x y z) yes no)
+(GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (GT (TEQshiftRAreg x y z) yes no)
+(GE (CMPconst [0] l:(XOR x y)) yes no) && l.Uses==1 -> (GE (TEQ x y) yes no)
+(GE (CMPconst [0] l:(XORconst [c] x)) yes no) && l.Uses==1 -> (GE (TEQconst [c] x) yes no)
+(GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no) && l.Uses==1 -> (GE (TEQshiftLL x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no) && l.Uses==1 -> (GE (TEQshiftRL x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no) && l.Uses==1 -> (GE (TEQshiftRA x y [c]) yes no)
+(GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no) && l.Uses==1 -> (GE (TEQshiftLLreg x y z) yes no)
+(GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no) && l.Uses==1 -> (GE (TEQshiftRLreg x y z) yes no)
+(GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no) && l.Uses==1 -> (GE (TEQshiftRAreg x y z) yes no)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUB x y)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUB x y)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMP x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUB {
+ l := v.Args[0]
+ if l.Op != OpARMSUB {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBconst [c] x)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBconst {
+ l := v.Args[0]
+ if l.Op != OpARMSUBconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftLL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftRL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftRA x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftLLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftRLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (SUBshiftRAreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADD x y)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADD x y)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMN x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADD {
+ l := v.Args[0]
+ if l.Op != OpARMADD {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDconst [c] x)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDconst {
+ l := v.Args[0]
+ if l.Op != OpARMADDconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftLL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftRL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftRA x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftLLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftRLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ADDshiftRAreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (AND x y)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(AND x y)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TST x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMAND {
+ l := v.Args[0]
+ if l.Op != OpARMAND {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDconst [c] x)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDconst {
+ l := v.Args[0]
+ if l.Op != OpARMANDconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftLL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftRL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftRA x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftLLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftRLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (ANDshiftRAreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XOR x y)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XOR x y)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQ x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXOR {
+ l := v.Args[0]
+ if l.Op != OpARMXOR {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORconst [c] x)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORconst {
+ l := v.Args[0]
+ if l.Op != OpARMXORconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftLL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftRL x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftRA x y [c])) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftLLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftRLreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (EQ (CMPconst [0] (XORshiftRAreg x y z)) yes no)
- // cond:
+ // match: (EQ (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (EQ (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMEQ
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(SUB x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMP x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (GE (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (GE (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (GE (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (GE (CMPconst [0] l:(SUBconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ADD x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMN x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (GE (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (GE (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (GE (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (GE (CMPconst [0] l:(ADDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(AND x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TST x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ANDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(XOR x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQ x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(XORconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GE (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(SUB x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMP x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (GT (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (GT (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (GT (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (GT (CMPconst [0] l:(SUBconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ADD x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMN x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ADDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(AND x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TST x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (GT (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (GT (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (GT (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (GT (CMPconst [0] l:(ANDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(XOR x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQ x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(XORconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (GT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (GT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (GT (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMGT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(SUB x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMP x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (LE (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (LE (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (LE (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (LE (CMPconst [0] l:(SUBconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ADD x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMN x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (LE (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (LE (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (LE (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (LE (CMPconst [0] l:(ADDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(AND x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TST x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ANDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(XOR x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQ x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(XORconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LE (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(SUB x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMP x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (LT (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (LT (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (LT (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (LT (CMPconst [0] l:(SUBconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ADD x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMN x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (LT (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (LT (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (LT (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
return true
}
// match: (LT (CMPconst [0] l:(ADDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(AND x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TST x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ANDconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(XOR x y)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQ x y) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(XORconst [c] x)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQconst [c] x) yes no)
for {
v := b.Control
}
c := l.AuxInt
x := l.Args[0]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
_ = l.Args[1]
x := l.Args[0]
y := l.Args[1]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
return true
}
// match: (LT (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
- b.Kind = BlockARMLT
+ if !(l.Uses == 1) {
+ break
+ }
+ b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
v0.AddArg(y)
return true
}
// match: (LT (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
- // cond:
+ // cond: l.Uses==1
// result: (LT (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
x := l.Args[0]
y := l.Args[1]
z := l.Args[2]
+ if !(l.Uses == 1) {
+ break
+ }
b.Kind = BlockARMLT
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUB x y)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUB x y)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMP x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUB {
+ l := v.Args[0]
+ if l.Op != OpARMSUB {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (MULS x y a)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(MULS x y a)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMP a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULS {
+ l := v.Args[0]
+ if l.Op != OpARMMULS {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMP, types.TypeFlags)
v0.AddArg(a)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBconst [c] x)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBconst {
+ l := v.Args[0]
+ if l.Op != OpARMSUBconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftLL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftRL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftRA x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftLLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftRLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (SUBshiftRAreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(SUBshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMPshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMSUBshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMSUBshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMPshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADD x y)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADD x y)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMN x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADD {
+ l := v.Args[0]
+ if l.Op != OpARMADD {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (MULA x y a)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(MULA x y a)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMN a (MUL <x.Type> x y)) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMMULA {
+ l := v.Args[0]
+ if l.Op != OpARMMULA {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ a := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- a := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMN, types.TypeFlags)
v0.AddArg(a)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDconst [c] x)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDconst {
+ l := v.Args[0]
+ if l.Op != OpARMADDconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftLL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftRL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftRA x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftLLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftRLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ADDshiftRAreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ADDshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (CMNshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMADDshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMADDshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMCMNshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (AND x y)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(AND x y)) yes no)
+ // cond: l.Uses==1
// result: (NE (TST x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMAND {
+ l := v.Args[0]
+ if l.Op != OpARMAND {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTST, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDconst [c] x)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDconst {
+ l := v.Args[0]
+ if l.Op != OpARMANDconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftLL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftRL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftRA x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftLLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftRLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (ANDshiftRAreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(ANDshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TSTshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMANDshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMANDshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTSTshiftRAreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XOR x y)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XOR x y)) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQ x y) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXOR {
+ l := v.Args[0]
+ if l.Op != OpARMXOR {
+ break
+ }
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQ, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORconst [c] x)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORconst [c] x)) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQconst [c] x) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORconst {
+ l := v.Args[0]
+ if l.Op != OpARMXORconst {
+ break
+ }
+ c := l.AuxInt
+ x := l.Args[0]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- x := v_0.Args[0]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQconst, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftLL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftLL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftLL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftLL {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftLL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftRL x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftRL x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftRL x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRL {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRL {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRL, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftRA x y [c])) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftRA x y [c])) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftRA x y [c]) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRA {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRA {
+ break
+ }
+ c := l.AuxInt
+ _ = l.Args[1]
+ x := l.Args[0]
+ y := l.Args[1]
+ if !(l.Uses == 1) {
break
}
- c := v_0.AuxInt
- _ = v_0.Args[1]
- x := v_0.Args[0]
- y := v_0.Args[1]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRA, types.TypeFlags)
v0.AuxInt = c
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftLLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftLLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftLLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftLLreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftLLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftLLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftRLreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftRLreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftRLreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRLreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRLreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRLreg, types.TypeFlags)
v0.AddArg(x)
b.Aux = nil
return true
}
- // match: (NE (CMPconst [0] (XORshiftRAreg x y z)) yes no)
- // cond:
+ // match: (NE (CMPconst [0] l:(XORshiftRAreg x y z)) yes no)
+ // cond: l.Uses==1
// result: (NE (TEQshiftRAreg x y z) yes no)
for {
v := b.Control
if v.AuxInt != 0 {
break
}
- v_0 := v.Args[0]
- if v_0.Op != OpARMXORshiftRAreg {
+ l := v.Args[0]
+ if l.Op != OpARMXORshiftRAreg {
+ break
+ }
+ _ = l.Args[2]
+ x := l.Args[0]
+ y := l.Args[1]
+ z := l.Args[2]
+ if !(l.Uses == 1) {
break
}
- _ = v_0.Args[2]
- x := v_0.Args[0]
- y := v_0.Args[1]
- z := v_0.Args[2]
b.Kind = BlockARMNE
v0 := b.NewValue0(v.Pos, OpARMTEQshiftRAreg, types.TypeFlags)
v0.AddArg(x)