From 067dfce21f945646b9e6bf2a7559eaaecf40b4d6 Mon Sep 17 00:00:00 2001 From: Ben Shi Date: Thu, 30 Aug 2018 01:19:58 +0000 Subject: [PATCH] cmd/compile: optimize ARM's comparision MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit Optimize (CMPconst [0] (ADD x y)) to (CMN x y) will only get benefits when the result of the addition is no longer used, otherwise there might be even performance drop. And this CL fixes that issue for CMP/CMN/TST/TEQ. There is little regression in the go1 benchmark (excluding noise), and the test case JSONDecode-4 even gets improvement. name old time/op new time/op delta BinaryTree17-4 21.6s ± 1% 21.6s ± 0% -0.22% (p=0.013 n=30+30) Fannkuch11-4 11.1s ± 0% 11.1s ± 0% +0.11% (p=0.000 n=30+29) FmtFprintfEmpty-4 297ns ± 0% 297ns ± 0% +0.08% (p=0.007 n=26+28) FmtFprintfString-4 589ns ± 1% 589ns ± 0% ~ (p=0.659 n=30+25) FmtFprintfInt-4 644ns ± 1% 650ns ± 0% +0.88% (p=0.000 n=30+24) FmtFprintfIntInt-4 964ns ± 0% 977ns ± 0% +1.33% (p=0.000 n=30+30) FmtFprintfPrefixedInt-4 1.06µs ± 0% 1.07µs ± 0% +1.31% (p=0.000 n=29+27) FmtFprintfFloat-4 1.89µs ± 0% 1.92µs ± 0% +1.25% (p=0.000 n=29+29) FmtManyArgs-4 3.63µs ± 0% 3.67µs ± 0% +1.33% (p=0.000 n=29+27) GobDecode-4 38.1ms ± 1% 37.9ms ± 1% -0.60% (p=0.000 n=29+29) GobEncode-4 35.3ms ± 2% 35.2ms ± 1% ~ (p=0.286 n=30+30) Gzip-4 2.36s ± 0% 2.37s ± 2% ~ (p=0.277 n=24+28) Gunzip-4 264ms ± 1% 264ms ± 1% ~ (p=0.104 n=28+30) HTTPClientServer-4 1.04ms ± 4% 1.02ms ± 4% -1.65% (p=0.000 n=28+28) JSONEncode-4 78.5ms ± 1% 79.6ms ± 1% +1.34% (p=0.000 n=27+28) JSONDecode-4 379ms ± 4% 352ms ± 5% -7.09% (p=0.000 n=29+30) Mandelbrot200-4 17.6ms ± 0% 17.6ms ± 0% ~ (p=0.206 n=28+29) GoParse-4 21.9ms ± 1% 22.1ms ± 1% +0.87% (p=0.000 n=28+26) RegexpMatchEasy0_32-4 631ns ± 0% 641ns ± 0% +1.63% (p=0.000 n=29+30) RegexpMatchEasy0_1K-4 4.11µs ± 0% 4.11µs ± 0% ~ (p=0.700 n=30+30) RegexpMatchEasy1_32-4 670ns ± 0% 679ns ± 0% +1.37% (p=0.000 n=21+30) RegexpMatchEasy1_1K-4 5.31µs ± 0% 5.26µs ± 0% -1.03% (p=0.000 n=25+28) RegexpMatchMedium_32-4 905ns ± 0% 906ns ± 0% +0.14% (p=0.001 n=30+30) RegexpMatchMedium_1K-4 192µs ± 0% 191µs ± 0% -0.45% (p=0.000 n=29+27) RegexpMatchHard_32-4 11.8µs ± 0% 11.7µs ± 0% -0.39% (p=0.000 n=29+28) RegexpMatchHard_1K-4 347µs ± 0% 347µs ± 0% ~ (p=0.084 n=29+30) Revcomp-4 37.5ms ± 1% 37.5ms ± 1% ~ (p=0.279 n=29+29) Template-4 519ms ± 2% 519ms ± 2% ~ (p=0.652 n=28+29) TimeParse-4 2.83µs ± 0% 2.78µs ± 0% -1.90% (p=0.000 n=27+28) TimeFormat-4 5.79µs ± 0% 5.60µs ± 0% -3.23% (p=0.000 n=29+29) [Geo mean] 331µs 330µs -0.16% name old speed new speed delta GobDecode-4 20.1MB/s ± 1% 20.3MB/s ± 1% +0.61% (p=0.000 n=29+29) GobEncode-4 21.7MB/s ± 2% 21.8MB/s ± 1% ~ (p=0.294 n=30+30) Gzip-4 8.23MB/s ± 1% 8.20MB/s ± 2% ~ (p=0.099 n=26+28) Gunzip-4 73.5MB/s ± 1% 73.4MB/s ± 1% ~ (p=0.107 n=28+30) JSONEncode-4 24.7MB/s ± 1% 24.4MB/s ± 1% -1.32% (p=0.000 n=27+28) JSONDecode-4 5.13MB/s ± 4% 5.52MB/s ± 5% +7.65% (p=0.000 n=29+30) GoParse-4 2.65MB/s ± 1% 2.63MB/s ± 1% -0.87% (p=0.000 n=28+26) RegexpMatchEasy0_32-4 50.7MB/s ± 0% 49.9MB/s ± 0% -1.58% (p=0.000 n=29+29) RegexpMatchEasy0_1K-4 249MB/s ± 0% 249MB/s ± 0% ~ (p=0.342 n=30+28) RegexpMatchEasy1_32-4 47.7MB/s ± 0% 47.1MB/s ± 0% -1.39% (p=0.000 n=26+30) RegexpMatchEasy1_1K-4 193MB/s ± 0% 195MB/s ± 0% +1.04% (p=0.000 n=25+28) RegexpMatchMedium_32-4 1.10MB/s ± 0% 1.10MB/s ± 0% -0.42% (p=0.000 n=30+26) RegexpMatchMedium_1K-4 5.33MB/s ± 0% 5.36MB/s ± 0% +0.43% (p=0.000 n=29+29) RegexpMatchHard_32-4 2.72MB/s ± 0% 2.73MB/s ± 0% +0.37% (p=0.000 n=29+30) RegexpMatchHard_1K-4 2.95MB/s ± 0% 2.95MB/s ± 0% ~ (all equal) Revcomp-4 67.8MB/s ± 1% 67.7MB/s ± 1% ~ (p=0.273 n=29+29) Template-4 3.74MB/s ± 2% 3.74MB/s ± 2% ~ (p=0.665 n=28+29) [Geo mean] 15.2MB/s 15.2MB/s +0.21% Change-Id: Ifed1fb8cc02d5ca52c8bc6c21b6b5bf6dbb2701a Reviewed-on: https://go-review.googlesource.com/132115 Run-TryBot: Ben Shi TryBot-Result: Gobot Gobot Reviewed-by: Cherry Zhang --- src/cmd/compile/internal/ssa/gen/ARM.rules | 408 ++-- src/cmd/compile/internal/ssa/rewriteARM.go | 2038 +++++++++++++------- test/codegen/comparisons.go | 15 +- 3 files changed, 1539 insertions(+), 922 deletions(-) diff --git a/src/cmd/compile/internal/ssa/gen/ARM.rules b/src/cmd/compile/internal/ssa/gen/ARM.rules index 8cea322295..fdf4d1e900 100644 --- a/src/cmd/compile/internal/ssa/gen/ARM.rules +++ b/src/cmd/compile/internal/ssa/gen/ARM.rules @@ -1340,207 +1340,207 @@ // 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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) diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go index 40d8d7f0b3..966413ab25 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM.go +++ b/src/cmd/compile/internal/ssa/rewriteARM.go @@ -22256,8 +22256,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22267,13 +22267,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22282,8 +22285,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -22293,14 +22296,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22312,8 +22318,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22323,12 +22329,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22337,8 +22346,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22348,14 +22357,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22365,8 +22377,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22376,14 +22388,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22393,8 +22408,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22404,14 +22419,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22421,8 +22439,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22432,14 +22450,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22449,8 +22470,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22460,14 +22481,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22477,8 +22501,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22488,14 +22512,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22505,8 +22532,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22516,13 +22543,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22531,8 +22561,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -22542,14 +22572,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22561,8 +22594,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22572,12 +22605,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22586,8 +22622,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22597,14 +22633,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22614,8 +22653,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22625,14 +22664,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22642,8 +22684,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22653,14 +22695,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22670,8 +22715,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22681,14 +22726,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22698,8 +22746,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22709,14 +22757,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22726,8 +22777,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22737,14 +22788,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22754,8 +22808,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22765,13 +22819,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22780,8 +22837,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22791,12 +22848,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22805,8 +22865,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22816,14 +22876,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22833,8 +22896,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22844,14 +22907,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22861,8 +22927,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22872,14 +22938,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22889,8 +22958,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22900,14 +22969,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22917,8 +22989,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22928,14 +23000,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22945,8 +23020,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22956,14 +23031,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22973,8 +23051,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -22984,13 +23062,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -22999,8 +23080,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23010,12 +23091,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23024,8 +23108,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23035,14 +23119,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23052,8 +23139,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23063,14 +23150,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23080,8 +23170,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23091,14 +23181,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23108,8 +23201,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23119,14 +23212,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23136,8 +23232,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23147,14 +23243,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23164,8 +23263,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23175,14 +23274,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23275,7 +23377,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23292,6 +23394,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -23300,8 +23405,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -23311,14 +23416,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23331,7 +23439,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23347,6 +23455,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -23356,7 +23467,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23374,6 +23485,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23384,7 +23498,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23402,6 +23516,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23412,7 +23529,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23430,6 +23547,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23440,7 +23560,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23458,6 +23578,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23468,7 +23591,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23486,6 +23609,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23496,7 +23622,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23514,6 +23640,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23524,7 +23653,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23541,6 +23670,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -23549,8 +23681,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -23560,14 +23692,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23580,7 +23715,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23596,6 +23731,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -23605,7 +23743,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23623,6 +23761,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23633,7 +23774,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23651,6 +23792,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23661,7 +23805,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23679,6 +23823,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23689,7 +23836,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23707,6 +23854,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23717,7 +23867,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23735,6 +23885,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23745,7 +23898,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23763,6 +23916,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23773,7 +23929,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23790,6 +23946,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -23799,7 +23958,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23815,6 +23974,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -23824,7 +23986,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23842,6 +24004,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23852,7 +24017,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23870,6 +24035,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23880,7 +24048,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23898,6 +24066,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -23908,7 +24079,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23926,6 +24097,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23936,7 +24110,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23954,6 +24128,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23964,7 +24141,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -23982,6 +24159,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -23992,7 +24172,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24009,6 +24189,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -24018,7 +24201,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24034,6 +24217,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -24043,7 +24229,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24061,6 +24247,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24071,7 +24260,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24089,6 +24278,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24099,7 +24291,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24117,6 +24309,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24127,7 +24322,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24145,6 +24340,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24155,7 +24353,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24173,6 +24371,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24183,7 +24384,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24201,6 +24402,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24294,7 +24498,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24311,6 +24515,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -24319,8 +24526,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -24330,14 +24537,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24350,7 +24560,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24366,6 +24576,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -24375,7 +24588,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24393,6 +24606,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24403,7 +24619,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24421,6 +24637,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24431,7 +24650,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24449,6 +24668,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24459,7 +24681,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24477,6 +24699,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24487,7 +24712,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24505,6 +24730,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24515,7 +24743,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24533,6 +24761,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24543,7 +24774,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24560,6 +24791,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -24569,7 +24803,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24585,6 +24819,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -24594,7 +24831,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24612,6 +24849,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24622,7 +24862,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24640,6 +24880,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24650,7 +24893,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24668,6 +24911,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24678,7 +24924,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24696,6 +24942,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24706,7 +24955,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24724,6 +24973,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24734,7 +24986,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24752,6 +25004,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24762,7 +25017,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24779,6 +25034,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -24787,8 +25045,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -24798,14 +25056,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24818,7 +25079,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24834,6 +25095,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -24843,7 +25107,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24861,6 +25125,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24871,7 +25138,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24889,6 +25156,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24899,7 +25169,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24917,6 +25187,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -24927,7 +25200,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24945,6 +25218,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24955,7 +25231,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -24973,6 +25249,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -24983,7 +25262,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25001,6 +25280,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25011,7 +25293,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25028,6 +25310,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -25037,7 +25322,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25053,6 +25338,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -25062,7 +25350,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25080,6 +25368,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25090,7 +25381,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25108,6 +25399,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25118,7 +25412,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25136,6 +25430,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25146,7 +25443,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25164,6 +25461,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25174,7 +25474,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25192,6 +25492,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25202,7 +25505,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25220,6 +25523,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25468,7 +25774,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25485,6 +25791,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -25493,8 +25802,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -25504,14 +25813,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25524,7 +25836,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25540,6 +25852,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -25549,7 +25864,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25567,6 +25882,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25577,7 +25895,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25595,6 +25913,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25605,7 +25926,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25623,6 +25944,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25633,7 +25957,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25651,6 +25975,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25661,7 +25988,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25679,6 +26006,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25689,7 +26019,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25707,6 +26037,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25717,7 +26050,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25734,6 +26067,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -25742,8 +26078,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -25753,14 +26089,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25773,7 +26112,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25789,6 +26128,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -25798,7 +26140,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25816,6 +26158,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25826,7 +26171,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25844,6 +26189,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25854,7 +26202,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25872,6 +26220,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -25882,7 +26233,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25900,6 +26251,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25910,7 +26264,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25928,6 +26282,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25938,7 +26295,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25956,6 +26313,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -25966,7 +26326,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -25983,6 +26343,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -25992,7 +26355,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26008,6 +26371,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -26017,7 +26383,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26035,6 +26401,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26045,7 +26414,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26063,6 +26432,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26073,7 +26445,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26091,6 +26463,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26101,7 +26476,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26119,6 +26494,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26129,7 +26507,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26147,6 +26525,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26157,7 +26538,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26175,6 +26556,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26185,7 +26569,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26202,6 +26586,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -26211,7 +26598,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26227,6 +26614,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -26236,7 +26626,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26254,6 +26644,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26264,7 +26657,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26282,6 +26675,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26292,7 +26688,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26310,6 +26706,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26320,7 +26719,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26338,6 +26737,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26348,7 +26750,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26366,6 +26768,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26376,7 +26781,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26394,6 +26799,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26487,7 +26895,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26504,6 +26912,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -26512,8 +26923,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -26523,14 +26934,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26543,7 +26957,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26559,6 +26973,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -26568,7 +26985,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26586,6 +27003,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26596,7 +27016,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26614,6 +27034,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26624,7 +27047,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26642,6 +27065,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26652,7 +27078,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26670,6 +27096,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26680,7 +27109,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26698,6 +27127,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26708,7 +27140,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26726,6 +27158,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26736,7 +27171,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26753,6 +27188,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -26761,8 +27199,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -26772,14 +27210,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26792,7 +27233,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26808,6 +27249,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -26817,7 +27261,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26835,6 +27279,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26845,7 +27292,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26863,6 +27310,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26873,7 +27323,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26891,6 +27341,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -26901,7 +27354,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26919,6 +27372,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26929,7 +27385,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26947,6 +27403,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26957,7 +27416,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -26975,6 +27434,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -26985,7 +27447,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27002,6 +27464,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -27011,7 +27476,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27027,6 +27492,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -27036,7 +27504,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27054,6 +27522,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27064,7 +27535,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27082,6 +27553,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27092,7 +27566,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27110,6 +27584,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27120,7 +27597,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27138,6 +27615,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27148,7 +27628,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27166,6 +27646,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27176,7 +27659,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27194,6 +27677,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27204,7 +27690,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27221,6 +27707,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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) @@ -27230,7 +27719,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27246,6 +27735,9 @@ func rewriteBlockARM(b *Block) bool { } 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 @@ -27255,7 +27747,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27273,6 +27765,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27283,7 +27778,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27301,6 +27796,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27311,7 +27809,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27329,6 +27827,9 @@ func rewriteBlockARM(b *Block) bool { _ = 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 @@ -27339,7 +27840,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27357,6 +27858,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27367,7 +27871,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27385,7 +27889,10 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27395,7 +27902,7 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27413,6 +27920,9 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27713,8 +28223,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27724,13 +28234,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27739,8 +28252,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -27750,14 +28263,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27769,8 +28285,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27780,12 +28296,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27794,8 +28313,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27805,14 +28324,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27822,8 +28344,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27833,14 +28355,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27850,8 +28375,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27861,14 +28386,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27878,8 +28406,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27889,14 +28417,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27906,8 +28437,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27917,14 +28448,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27934,8 +28468,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27945,14 +28479,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27962,8 +28499,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -27973,13 +28510,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -27988,8 +28528,8 @@ func rewriteBlockARM(b *Block) bool { 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 y)) yes no) for { v := b.Control @@ -27999,14 +28539,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28018,8 +28561,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28029,12 +28572,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28043,8 +28589,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28054,14 +28600,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28071,8 +28620,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28082,14 +28631,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28099,8 +28651,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28110,14 +28662,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28127,8 +28682,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28138,14 +28693,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28155,8 +28713,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28166,14 +28724,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28183,8 +28744,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28194,14 +28755,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28211,8 +28775,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28222,13 +28786,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28237,8 +28804,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28248,12 +28815,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28262,8 +28832,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28273,14 +28843,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28290,8 +28863,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28301,14 +28874,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28318,8 +28894,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28329,14 +28905,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28346,8 +28925,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28357,14 +28936,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28374,8 +28956,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28385,14 +28967,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28402,8 +28987,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28413,14 +28998,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28430,8 +29018,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28441,13 +29029,16 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28456,8 +29047,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28467,12 +29058,15 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28481,8 +29075,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28492,14 +29086,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28509,8 +29106,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28520,14 +29117,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28537,8 +29137,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28548,14 +29148,17 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28565,8 +29168,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28576,14 +29179,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28593,8 +29199,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28604,14 +29210,17 @@ func rewriteBlockARM(b *Block) bool { 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) @@ -28621,8 +29230,8 @@ func rewriteBlockARM(b *Block) bool { 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 @@ -28632,14 +29241,17 @@ func rewriteBlockARM(b *Block) bool { 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) diff --git a/test/codegen/comparisons.go b/test/codegen/comparisons.go index 8475b130c2..50c9de7626 100644 --- a/test/codegen/comparisons.go +++ b/test/codegen/comparisons.go @@ -158,9 +158,11 @@ func CmpZero4(a int64, ptr *int) { } } -func CmpToZero(a, b, d int32) int32 { +func CmpToZero(a, b, d int32, e, f int64) int32 { // arm:`TST`,-`AND` // arm64:`TSTW`,-`AND` + // 386:`TESTL`,-`ANDL` + // amd64:`TESTL`,-`ANDL` c0 := a&b < 0 // arm:`CMN`,-`ADD` // arm64:`CMNW`,-`ADD` @@ -168,14 +170,17 @@ func CmpToZero(a, b, d int32) int32 { // arm:`TEQ`,-`XOR` c2 := a^b < 0 // arm64:`TST`,-`AND` - c3 := int64(a)&int64(b) < 0 + // amd64:`TESTQ`,-`ANDQ` + c3 := e&f < 0 // arm64:`CMN`,-`ADD` - c4 := int64(a)+int64(b) < 0 - // not optimized to CMNW/CMN due to further use of b+d + c4 := e+f < 0 + // not optimized to single CMNW/CMN due to further use of b+d // arm64:`ADD`,-`CMNW` + // arm:`ADD`,-`CMN` c5 := b+d == 0 - // not optimized to TSTW/TST due to further use of a&d + // not optimized to single TSTW/TST due to further use of a&d // arm64:`AND`,-`TSTW` + // arm:`AND`,-`TST` c6 := a&d >= 0 if c0 { return 1 -- 2.50.0