mirror
/
go
mirror of https://github.com/golang/go.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

cmd/compile: convert more ARM64.rules lines to typed aux mode 

Add a check code for checking whether the "c" value can be
represented as a signed 32 bit integer in some rules.

Passes toolstash-check -all.

Change-Id: I84e4431dc75945985695516d34565b841c8b53e0
Reviewed-on: https://go-review.googlesource.com/c/go/+/233738
Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
fanzha02 2020-05-12 11:05:24 +08:00 committed by fannie zhang
parent aa49a0b372
commit 328214e85c
2 changed files with 335 additions and 291 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

266
src/cmd/compile/internal/ssa/gen/ARM64.rules
View File

@ -950,41 +950,41 @@
(STP [off] {sym} ptr (MOVDconst [0]) (MOVDconst [0]) mem) => (MOVQstorezero [off] {sym} ptr mem)
// register indexed store zero
(MOVDstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil -> (MOVDstorezeroidx ptr idx mem)
(MOVWstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil -> (MOVWstorezeroidx ptr idx mem)
(MOVHstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil -> (MOVHstorezeroidx ptr idx mem)
(MOVBstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil -> (MOVBstorezeroidx ptr idx mem)
(MOVDstoreidx ptr idx (MOVDconst [0]) mem) -> (MOVDstorezeroidx ptr idx mem)
(MOVWstoreidx ptr idx (MOVDconst [0]) mem) -> (MOVWstorezeroidx ptr idx mem)
(MOVHstoreidx ptr idx (MOVDconst [0]) mem) -> (MOVHstorezeroidx ptr idx mem)
(MOVBstoreidx ptr idx (MOVDconst [0]) mem) -> (MOVBstorezeroidx ptr idx mem)
(MOVDstorezeroidx ptr (MOVDconst [c]) mem) -> (MOVDstorezero [c] ptr mem)
(MOVDstorezeroidx (MOVDconst [c]) idx mem) -> (MOVDstorezero [c] idx mem)
(MOVWstorezeroidx ptr (MOVDconst [c]) mem) -> (MOVWstorezero [c] ptr mem)
(MOVWstorezeroidx (MOVDconst [c]) idx mem) -> (MOVWstorezero [c] idx mem)
(MOVHstorezeroidx ptr (MOVDconst [c]) mem) -> (MOVHstorezero [c] ptr mem)
(MOVHstorezeroidx (MOVDconst [c]) idx mem) -> (MOVHstorezero [c] idx mem)
(MOVBstorezeroidx ptr (MOVDconst [c]) mem) -> (MOVBstorezero [c] ptr mem)
(MOVBstorezeroidx (MOVDconst [c]) idx mem) -> (MOVBstorezero [c] idx mem)
(MOVDstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil => (MOVDstorezeroidx ptr idx mem)
(MOVWstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil => (MOVWstorezeroidx ptr idx mem)
(MOVHstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil => (MOVHstorezeroidx ptr idx mem)
(MOVBstorezero [off] {sym} (ADD ptr idx) mem) && off == 0 && sym == nil => (MOVBstorezeroidx ptr idx mem)
(MOVDstoreidx ptr idx (MOVDconst [0]) mem) => (MOVDstorezeroidx ptr idx mem)
(MOVWstoreidx ptr idx (MOVDconst [0]) mem) => (MOVWstorezeroidx ptr idx mem)
(MOVHstoreidx ptr idx (MOVDconst [0]) mem) => (MOVHstorezeroidx ptr idx mem)
(MOVBstoreidx ptr idx (MOVDconst [0]) mem) => (MOVBstorezeroidx ptr idx mem)
(MOVDstorezeroidx ptr (MOVDconst [c]) mem) && is32Bit(c) => (MOVDstorezero [int32(c)] ptr mem)
(MOVDstorezeroidx (MOVDconst [c]) idx mem) && is32Bit(c) => (MOVDstorezero [int32(c)] idx mem)
(MOVWstorezeroidx ptr (MOVDconst [c]) mem) && is32Bit(c) => (MOVWstorezero [int32(c)] ptr mem)
(MOVWstorezeroidx (MOVDconst [c]) idx mem) && is32Bit(c) => (MOVWstorezero [int32(c)] idx mem)
(MOVHstorezeroidx ptr (MOVDconst [c]) mem) && is32Bit(c) => (MOVHstorezero [int32(c)] ptr mem)
(MOVHstorezeroidx (MOVDconst [c]) idx mem) && is32Bit(c) => (MOVHstorezero [int32(c)] idx mem)
(MOVBstorezeroidx ptr (MOVDconst [c]) mem) && is32Bit(c) => (MOVBstorezero [int32(c)] ptr mem)
(MOVBstorezeroidx (MOVDconst [c]) idx mem) && is32Bit(c) => (MOVBstorezero [int32(c)] idx mem)
// shifted register indexed store zero
(MOVDstorezero [off] {sym} (ADDshiftLL [3] ptr idx) mem) && off == 0 && sym == nil -> (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezero [off] {sym} (ADDshiftLL [2] ptr idx) mem) && off == 0 && sym == nil -> (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezero [off] {sym} (ADDshiftLL [1] ptr idx) mem) && off == 0 && sym == nil -> (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx ptr (SLLconst [3] idx) mem) -> (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezeroidx ptr (SLLconst [2] idx) mem) -> (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezeroidx ptr (SLLconst [1] idx) mem) -> (MOVHstorezeroidx2 ptr idx mem)
(MOVHstorezeroidx ptr (ADD idx idx) mem) -> (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx (SLLconst [3] idx) ptr mem) -> (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezeroidx (SLLconst [2] idx) ptr mem) -> (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezeroidx (SLLconst [1] idx) ptr mem) -> (MOVHstorezeroidx2 ptr idx mem)
(MOVHstorezeroidx (ADD idx idx) ptr mem) -> (MOVHstorezeroidx2 ptr idx mem)
(MOVDstoreidx8 ptr idx (MOVDconst [0]) mem) -> (MOVDstorezeroidx8 ptr idx mem)
(MOVWstoreidx4 ptr idx (MOVDconst [0]) mem) -> (MOVWstorezeroidx4 ptr idx mem)
(MOVHstoreidx2 ptr idx (MOVDconst [0]) mem) -> (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx8 ptr (MOVDconst [c]) mem) -> (MOVDstorezero [c<<3] ptr mem)
(MOVWstorezeroidx4 ptr (MOVDconst [c]) mem) -> (MOVWstorezero [c<<2] ptr mem)
(MOVHstorezeroidx2 ptr (MOVDconst [c]) mem) -> (MOVHstorezero [c<<1] ptr mem)
(MOVDstorezero [off] {sym} (ADDshiftLL [3] ptr idx) mem) && off == 0 && sym == nil => (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezero [off] {sym} (ADDshiftLL [2] ptr idx) mem) && off == 0 && sym == nil => (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezero [off] {sym} (ADDshiftLL [1] ptr idx) mem) && off == 0 && sym == nil => (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx ptr (SLLconst [3] idx) mem) => (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezeroidx ptr (SLLconst [2] idx) mem) => (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezeroidx ptr (SLLconst [1] idx) mem) => (MOVHstorezeroidx2 ptr idx mem)
(MOVHstorezeroidx ptr (ADD idx idx) mem) => (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx (SLLconst [3] idx) ptr mem) => (MOVDstorezeroidx8 ptr idx mem)
(MOVWstorezeroidx (SLLconst [2] idx) ptr mem) => (MOVWstorezeroidx4 ptr idx mem)
(MOVHstorezeroidx (SLLconst [1] idx) ptr mem) => (MOVHstorezeroidx2 ptr idx mem)
(MOVHstorezeroidx (ADD idx idx) ptr mem) => (MOVHstorezeroidx2 ptr idx mem)
(MOVDstoreidx8 ptr idx (MOVDconst [0]) mem) => (MOVDstorezeroidx8 ptr idx mem)
(MOVWstoreidx4 ptr idx (MOVDconst [0]) mem) => (MOVWstorezeroidx4 ptr idx mem)
(MOVHstoreidx2 ptr idx (MOVDconst [0]) mem) => (MOVHstorezeroidx2 ptr idx mem)
(MOVDstorezeroidx8 ptr (MOVDconst [c]) mem) && is32Bit(c<<3) => (MOVDstorezero [int32(c<<3)] ptr mem)
(MOVWstorezeroidx4 ptr (MOVDconst [c]) mem) && is32Bit(c<<2) => (MOVWstorezero [int32(c<<2)] ptr mem)
(MOVHstorezeroidx2 ptr (MOVDconst [c]) mem) && is32Bit(c<<1) => (MOVHstorezero [int32(c<<1)] ptr mem)
// replace load from same location as preceding store with zero/sign extension (or copy in case of full width)
// these seem to have bad interaction with other rules, resulting in slower code
@ -998,121 +998,121 @@
//(FMOVSload [off] {sym} ptr (FMOVSstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
//(FMOVDload [off] {sym} ptr (FMOVDstore [off2] {sym2} ptr2 x _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> x
(MOVBload [off] {sym} ptr (MOVBstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVBUload [off] {sym} ptr (MOVBstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVHload [off] {sym} ptr (MOVHstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVHUload [off] {sym} ptr (MOVHstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVWload [off] {sym} ptr (MOVWstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVWUload [off] {sym} ptr (MOVWstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVDload [off] {sym} ptr (MOVDstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) -> (MOVDconst [0])
(MOVBload [off] {sym} ptr (MOVBstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVBUload [off] {sym} ptr (MOVBstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVHload [off] {sym} ptr (MOVHstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVHUload [off] {sym} ptr (MOVHstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVWload [off] {sym} ptr (MOVWstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVWUload [off] {sym} ptr (MOVWstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVDload [off] {sym} ptr (MOVDstorezero [off2] {sym2} ptr2 _)) && sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) => (MOVDconst [0])
(MOVBloadidx ptr idx (MOVBstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVBUloadidx ptr idx (MOVBstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVHloadidx ptr idx (MOVHstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVHUloadidx ptr idx (MOVHstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVWloadidx ptr idx (MOVWstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVWUloadidx ptr idx (MOVWstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVDloadidx ptr idx (MOVDstorezeroidx ptr2 idx2 _))
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) -> (MOVDconst [0])
&& (isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) || isSamePtr(ptr, idx2) && isSamePtr(idx, ptr2)) => (MOVDconst [0])
(MOVHloadidx2 ptr idx (MOVHstorezeroidx2 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) -> (MOVDconst [0])
(MOVHUloadidx2 ptr idx (MOVHstorezeroidx2 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) -> (MOVDconst [0])
(MOVWloadidx4 ptr idx (MOVWstorezeroidx4 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) -> (MOVDconst [0])
(MOVWUloadidx4 ptr idx (MOVWstorezeroidx4 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) -> (MOVDconst [0])
(MOVDloadidx8 ptr idx (MOVDstorezeroidx8 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) -> (MOVDconst [0])
(MOVHloadidx2 ptr idx (MOVHstorezeroidx2 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) => (MOVDconst [0])
(MOVHUloadidx2 ptr idx (MOVHstorezeroidx2 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) => (MOVDconst [0])
(MOVWloadidx4 ptr idx (MOVWstorezeroidx4 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) => (MOVDconst [0])
(MOVWUloadidx4 ptr idx (MOVWstorezeroidx4 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) => (MOVDconst [0])
(MOVDloadidx8 ptr idx (MOVDstorezeroidx8 ptr2 idx2 _)) && isSamePtr(ptr, ptr2) && isSamePtr(idx, idx2) => (MOVDconst [0])
// don't extend after proper load
(MOVBreg x:(MOVBload _ _)) -> (MOVDreg x)
(MOVBUreg x:(MOVBUload _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVBload _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVBUload _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVHload _ _)) -> (MOVDreg x)
(MOVHUreg x:(MOVBUload _ _)) -> (MOVDreg x)
(MOVHUreg x:(MOVHUload _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVBload _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVBUload _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHload _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHUload _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVWload _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVBUload _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVHUload _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVWUload _ _)) -> (MOVDreg x)
(MOVBreg x:(MOVBloadidx _ _ _)) -> (MOVDreg x)
(MOVBUreg x:(MOVBUloadidx _ _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVBloadidx _ _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVBUloadidx _ _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVHloadidx _ _ _)) -> (MOVDreg x)
(MOVHUreg x:(MOVBUloadidx _ _ _)) -> (MOVDreg x)
(MOVHUreg x:(MOVHUloadidx _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVBloadidx _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVBUloadidx _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHloadidx _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHUloadidx _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVWloadidx _ _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVBUloadidx _ _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVHUloadidx _ _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVWUloadidx _ _ _)) -> (MOVDreg x)
(MOVHreg x:(MOVHloadidx2 _ _ _)) -> (MOVDreg x)
(MOVHUreg x:(MOVHUloadidx2 _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHloadidx2 _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVHUloadidx2 _ _ _)) -> (MOVDreg x)
(MOVWreg x:(MOVWloadidx4 _ _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVHUloadidx2 _ _ _)) -> (MOVDreg x)
(MOVWUreg x:(MOVWUloadidx4 _ _ _)) -> (MOVDreg x)
(MOVBreg x:(MOVBload _ _)) => (MOVDreg x)
(MOVBUreg x:(MOVBUload _ _)) => (MOVDreg x)
(MOVHreg x:(MOVBload _ _)) => (MOVDreg x)
(MOVHreg x:(MOVBUload _ _)) => (MOVDreg x)
(MOVHreg x:(MOVHload _ _)) => (MOVDreg x)
(MOVHUreg x:(MOVBUload _ _)) => (MOVDreg x)
(MOVHUreg x:(MOVHUload _ _)) => (MOVDreg x)
(MOVWreg x:(MOVBload _ _)) => (MOVDreg x)
(MOVWreg x:(MOVBUload _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHload _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHUload _ _)) => (MOVDreg x)
(MOVWreg x:(MOVWload _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVBUload _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVHUload _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVWUload _ _)) => (MOVDreg x)
(MOVBreg x:(MOVBloadidx _ _ _)) => (MOVDreg x)
(MOVBUreg x:(MOVBUloadidx _ _ _)) => (MOVDreg x)
(MOVHreg x:(MOVBloadidx _ _ _)) => (MOVDreg x)
(MOVHreg x:(MOVBUloadidx _ _ _)) => (MOVDreg x)
(MOVHreg x:(MOVHloadidx _ _ _)) => (MOVDreg x)
(MOVHUreg x:(MOVBUloadidx _ _ _)) => (MOVDreg x)
(MOVHUreg x:(MOVHUloadidx _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVBloadidx _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVBUloadidx _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHloadidx _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHUloadidx _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVWloadidx _ _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVBUloadidx _ _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVHUloadidx _ _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVWUloadidx _ _ _)) => (MOVDreg x)
(MOVHreg x:(MOVHloadidx2 _ _ _)) => (MOVDreg x)
(MOVHUreg x:(MOVHUloadidx2 _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHloadidx2 _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVHUloadidx2 _ _ _)) => (MOVDreg x)
(MOVWreg x:(MOVWloadidx4 _ _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVHUloadidx2 _ _ _)) => (MOVDreg x)
(MOVWUreg x:(MOVWUloadidx4 _ _ _)) => (MOVDreg x)
// fold double extensions
(MOVBreg x:(MOVBreg _)) -> (MOVDreg x)
(MOVBUreg x:(MOVBUreg _)) -> (MOVDreg x)
(MOVHreg x:(MOVBreg _)) -> (MOVDreg x)
(MOVHreg x:(MOVBUreg _)) -> (MOVDreg x)
(MOVHreg x:(MOVHreg _)) -> (MOVDreg x)
(MOVHUreg x:(MOVBUreg _)) -> (MOVDreg x)
(MOVHUreg x:(MOVHUreg _)) -> (MOVDreg x)
(MOVWreg x:(MOVBreg _)) -> (MOVDreg x)
(MOVWreg x:(MOVBUreg _)) -> (MOVDreg x)
(MOVWreg x:(MOVHreg _)) -> (MOVDreg x)
(MOVWreg x:(MOVWreg _)) -> (MOVDreg x)
(MOVWUreg x:(MOVBUreg _)) -> (MOVDreg x)
(MOVWUreg x:(MOVHUreg _)) -> (MOVDreg x)
(MOVWUreg x:(MOVWUreg _)) -> (MOVDreg x)
(MOVBreg x:(MOVBreg _)) => (MOVDreg x)
(MOVBUreg x:(MOVBUreg _)) => (MOVDreg x)
(MOVHreg x:(MOVBreg _)) => (MOVDreg x)
(MOVHreg x:(MOVBUreg _)) => (MOVDreg x)
(MOVHreg x:(MOVHreg _)) => (MOVDreg x)
(MOVHUreg x:(MOVBUreg _)) => (MOVDreg x)
(MOVHUreg x:(MOVHUreg _)) => (MOVDreg x)
(MOVWreg x:(MOVBreg _)) => (MOVDreg x)
(MOVWreg x:(MOVBUreg _)) => (MOVDreg x)
(MOVWreg x:(MOVHreg _)) => (MOVDreg x)
(MOVWreg x:(MOVWreg _)) => (MOVDreg x)
(MOVWUreg x:(MOVBUreg _)) => (MOVDreg x)
(MOVWUreg x:(MOVHUreg _)) => (MOVDreg x)
(MOVWUreg x:(MOVWUreg _)) => (MOVDreg x)
// don't extend before store
(MOVBstore [off] {sym} ptr (MOVBreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVBUreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVHreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVHUreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVWreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVWUreg x) mem) -> (MOVBstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVHreg x) mem) -> (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVHUreg x) mem) -> (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVWreg x) mem) -> (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVWUreg x) mem) -> (MOVHstore [off] {sym} ptr x mem)
(MOVWstore [off] {sym} ptr (MOVWreg x) mem) -> (MOVWstore [off] {sym} ptr x mem)
(MOVWstore [off] {sym} ptr (MOVWUreg x) mem) -> (MOVWstore [off] {sym} ptr x mem)
(MOVBstoreidx ptr idx (MOVBreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVBUreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVHreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVHUreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVWreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVWUreg x) mem) -> (MOVBstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVHreg x) mem) -> (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVHUreg x) mem) -> (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVWreg x) mem) -> (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVWUreg x) mem) -> (MOVHstoreidx ptr idx x mem)
(MOVWstoreidx ptr idx (MOVWreg x) mem) -> (MOVWstoreidx ptr idx x mem)
(MOVWstoreidx ptr idx (MOVWUreg x) mem) -> (MOVWstoreidx ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVHreg x) mem) -> (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVHUreg x) mem) -> (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVWreg x) mem) -> (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVWUreg x) mem) -> (MOVHstoreidx2 ptr idx x mem)
(MOVWstoreidx4 ptr idx (MOVWreg x) mem) -> (MOVWstoreidx4 ptr idx x mem)
(MOVWstoreidx4 ptr idx (MOVWUreg x) mem) -> (MOVWstoreidx4 ptr idx x mem)
(MOVBstore [off] {sym} ptr (MOVBreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVBUreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVHreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVHUreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVWreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVBstore [off] {sym} ptr (MOVWUreg x) mem) => (MOVBstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVHreg x) mem) => (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVHUreg x) mem) => (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVWreg x) mem) => (MOVHstore [off] {sym} ptr x mem)
(MOVHstore [off] {sym} ptr (MOVWUreg x) mem) => (MOVHstore [off] {sym} ptr x mem)
(MOVWstore [off] {sym} ptr (MOVWreg x) mem) => (MOVWstore [off] {sym} ptr x mem)
(MOVWstore [off] {sym} ptr (MOVWUreg x) mem) => (MOVWstore [off] {sym} ptr x mem)
(MOVBstoreidx ptr idx (MOVBreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVBUreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVHreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVHUreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVWreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVBstoreidx ptr idx (MOVWUreg x) mem) => (MOVBstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVHreg x) mem) => (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVHUreg x) mem) => (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVWreg x) mem) => (MOVHstoreidx ptr idx x mem)
(MOVHstoreidx ptr idx (MOVWUreg x) mem) => (MOVHstoreidx ptr idx x mem)
(MOVWstoreidx ptr idx (MOVWreg x) mem) => (MOVWstoreidx ptr idx x mem)
(MOVWstoreidx ptr idx (MOVWUreg x) mem) => (MOVWstoreidx ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVHreg x) mem) => (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVHUreg x) mem) => (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVWreg x) mem) => (MOVHstoreidx2 ptr idx x mem)
(MOVHstoreidx2 ptr idx (MOVWUreg x) mem) => (MOVHstoreidx2 ptr idx x mem)
(MOVWstoreidx4 ptr idx (MOVWreg x) mem) => (MOVWstoreidx4 ptr idx x mem)
(MOVWstoreidx4 ptr idx (MOVWUreg x) mem) => (MOVWstoreidx4 ptr idx x mem)
// if a register move has only 1 use, just use the same register without emitting instruction
// MOVDnop doesn't emit instruction, only for ensuring the type.

360
src/cmd/compile/internal/ssa/rewriteARM64.go
View File

@ -6248,20 +6248,20 @@ func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVBstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
// match: (MOVBUload [off] {sym} (SB) _)
@ -6334,7 +6334,7 @@ func rewriteValueARM64_OpARM64MOVBUloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -6517,20 +6517,20 @@ func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVBstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -6590,7 +6590,7 @@ func rewriteValueARM64_OpARM64MOVBloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -6750,8 +6750,8 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVBreg {
break
@ -6759,16 +6759,16 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVBstore [off] {sym} ptr (MOVBUreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVBUreg {
break
@ -6776,16 +6776,16 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVBstore [off] {sym} ptr (MOVHreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHreg {
break
@ -6793,16 +6793,16 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVBstore [off] {sym} ptr (MOVHUreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHUreg {
break
@ -6810,16 +6810,16 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVBstore [off] {sym} ptr (MOVWreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWreg {
break
@ -6827,16 +6827,16 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVBstore [off] {sym} ptr (MOVWUreg x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWUreg {
break
@ -6844,8 +6844,8 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVBstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
@ -8221,7 +8221,7 @@ func rewriteValueARM64_OpARM64MOVBstoreidx(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -8566,8 +8566,8 @@ func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVBstorezeroidx ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADD {
break
}
@ -8647,30 +8647,38 @@ func rewriteValueARM64_OpARM64MOVBstorezeroidx(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezeroidx ptr (MOVDconst [c]) mem)
// result: (MOVBstorezero [c] ptr mem)
// cond: is32Bit(c)
// result: (MOVBstorezero [int32(c)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVBstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(ptr, mem)
return true
}
// match: (MOVBstorezeroidx (MOVDconst [c]) idx mem)
// result: (MOVBstorezero [c] idx mem)
// cond: is32Bit(c)
// result: (MOVBstorezero [int32(c)] idx mem)
for {
if v_0.Op != OpARM64MOVDconst {
break
}
c := v_0.AuxInt
c := auxIntToInt64(v_0.AuxInt)
idx := v_1
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVBstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(idx, mem)
return true
}
@ -8804,20 +8812,20 @@ func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVDstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
// match: (MOVDload [off] {sym} (SB) _)
@ -8916,7 +8924,7 @@ func rewriteValueARM64_OpARM64MOVDloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -8958,7 +8966,7 @@ func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -9192,7 +9200,7 @@ func rewriteValueARM64_OpARM64MOVDstoreidx(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -9231,7 +9239,7 @@ func rewriteValueARM64_OpARM64MOVDstoreidx8(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -9293,8 +9301,8 @@ func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVDstorezeroidx ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADD {
break
}
@ -9312,9 +9320,9 @@ func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVDstorezeroidx8 ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
if v_0.Op != OpARM64ADDshiftLL || v_0.AuxInt != 3 {
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 3 {
break
}
idx := v_0.Args[1]
@ -9426,30 +9434,38 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstorezeroidx ptr (MOVDconst [c]) mem)
// result: (MOVDstorezero [c] ptr mem)
// cond: is32Bit(c)
// result: (MOVDstorezero [int32(c)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVDstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(ptr, mem)
return true
}
// match: (MOVDstorezeroidx (MOVDconst [c]) idx mem)
// result: (MOVDstorezero [c] idx mem)
// cond: is32Bit(c)
// result: (MOVDstorezero [int32(c)] idx mem)
for {
if v_0.Op != OpARM64MOVDconst {
break
}
c := v_0.AuxInt
c := auxIntToInt64(v_0.AuxInt)
idx := v_1
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVDstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(idx, mem)
return true
}
@ -9457,7 +9473,7 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx(v *Value) bool {
// result: (MOVDstorezeroidx8 ptr idx mem)
for {
ptr := v_0
if v_1.Op != OpARM64SLLconst || v_1.AuxInt != 3 {
if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 3 {
break
}
idx := v_1.Args[0]
@ -9469,7 +9485,7 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx(v *Value) bool {
// match: (MOVDstorezeroidx (SLLconst [3] idx) ptr mem)
// result: (MOVDstorezeroidx8 ptr idx mem)
for {
if v_0.Op != OpARM64SLLconst || v_0.AuxInt != 3 {
if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 3 {
break
}
idx := v_0.Args[0]
@ -9486,16 +9502,20 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstorezeroidx8 ptr (MOVDconst [c]) mem)
// result: (MOVDstorezero [c<<3] ptr mem)
// cond: is32Bit(c<<3)
// result: (MOVDstorezero [int32(c<<3)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c << 3)) {
break
}
v.reset(OpARM64MOVDstorezero)
v.AuxInt = c << 3
v.AuxInt = int32ToAuxInt(int32(c << 3))
v.AddArg2(ptr, mem)
return true
}
@ -9591,20 +9611,20 @@ func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
// match: (MOVHUload [off] {sym} (SB) _)
@ -9722,7 +9742,7 @@ func rewriteValueARM64_OpARM64MOVHUloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -9764,7 +9784,7 @@ func rewriteValueARM64_OpARM64MOVHUloadidx2(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -9998,20 +10018,20 @@ func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -10116,7 +10136,7 @@ func rewriteValueARM64_OpARM64MOVHloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -10158,7 +10178,7 @@ func rewriteValueARM64_OpARM64MOVHloadidx2(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -10415,8 +10435,8 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
// result: (MOVHstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHreg {
break
@ -10424,16 +10444,16 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVHstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVHstore [off] {sym} ptr (MOVHUreg x) mem)
// result: (MOVHstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVHUreg {
break
@ -10441,16 +10461,16 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVHstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVHstore [off] {sym} ptr (MOVWreg x) mem)
// result: (MOVHstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWreg {
break
@ -10458,16 +10478,16 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVHstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVHstore [off] {sym} ptr (MOVWUreg x) mem)
// result: (MOVHstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWUreg {
break
@ -10475,8 +10495,8 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVHstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
@ -10998,7 +11018,7 @@ func rewriteValueARM64_OpARM64MOVHstoreidx(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -11118,7 +11138,7 @@ func rewriteValueARM64_OpARM64MOVHstoreidx2(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -11236,8 +11256,8 @@ func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVHstorezeroidx ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADD {
break
}
@ -11255,9 +11275,9 @@ func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVHstorezeroidx2 ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
if v_0.Op != OpARM64ADDshiftLL || v_0.AuxInt != 1 {
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 1 {
break
}
idx := v_0.Args[1]
@ -11366,30 +11386,38 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezeroidx ptr (MOVDconst [c]) mem)
// result: (MOVHstorezero [c] ptr mem)
// cond: is32Bit(c)
// result: (MOVHstorezero [int32(c)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVHstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(ptr, mem)
return true
}
// match: (MOVHstorezeroidx (MOVDconst [c]) idx mem)
// result: (MOVHstorezero [c] idx mem)
// cond: is32Bit(c)
// result: (MOVHstorezero [int32(c)] idx mem)
for {
if v_0.Op != OpARM64MOVDconst {
break
}
c := v_0.AuxInt
c := auxIntToInt64(v_0.AuxInt)
idx := v_1
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVHstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(idx, mem)
return true
}
@ -11397,7 +11425,7 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx(v *Value) bool {
// result: (MOVHstorezeroidx2 ptr idx mem)
for {
ptr := v_0
if v_1.Op != OpARM64SLLconst || v_1.AuxInt != 1 {
if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 1 {
break
}
idx := v_1.Args[0]
@ -11425,7 +11453,7 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx(v *Value) bool {
// match: (MOVHstorezeroidx (SLLconst [1] idx) ptr mem)
// result: (MOVHstorezeroidx2 ptr idx mem)
for {
if v_0.Op != OpARM64SLLconst || v_0.AuxInt != 1 {
if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 1 {
break
}
idx := v_0.Args[0]
@ -11479,16 +11507,20 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx2(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezeroidx2 ptr (MOVDconst [c]) mem)
// result: (MOVHstorezero [c<<1] ptr mem)
// cond: is32Bit(c<<1)
// result: (MOVHstorezero [int32(c<<1)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c << 1)) {
break
}
v.reset(OpARM64MOVHstorezero)
v.AuxInt = c << 1
v.AuxInt = int32ToAuxInt(int32(c << 1))
v.AddArg2(ptr, mem)
return true
}
@ -11651,20 +11683,20 @@ func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
// match: (MOVWUload [off] {sym} (SB) _)
@ -11763,7 +11795,7 @@ func rewriteValueARM64_OpARM64MOVWUloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -11805,7 +11837,7 @@ func rewriteValueARM64_OpARM64MOVWUloadidx4(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -12083,20 +12115,20 @@ func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDconst [0])
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWstorezero {
break
}
off2 := v_1.AuxInt
sym2 := v_1.Aux
off2 := auxIntToInt32(v_1.AuxInt)
sym2 := auxToSym(v_1.Aux)
ptr2 := v_1.Args[0]
if !(sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)) {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -12182,7 +12214,7 @@ func rewriteValueARM64_OpARM64MOVWloadidx(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -12224,7 +12256,7 @@ func rewriteValueARM64_OpARM64MOVWloadidx4(v *Value) bool {
break
}
v.reset(OpARM64MOVDconst)
v.AuxInt = 0
v.AuxInt = int64ToAuxInt(0)
return true
}
return false
@ -12575,8 +12607,8 @@ func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
// result: (MOVWstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWreg {
break
@ -12584,16 +12616,16 @@ func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVWstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
// match: (MOVWstore [off] {sym} ptr (MOVWUreg x) mem)
// result: (MOVWstore [off] {sym} ptr x mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
ptr := v_0
if v_1.Op != OpARM64MOVWUreg {
break
@ -12601,8 +12633,8 @@ func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
x := v_1.Args[0]
mem := v_2
v.reset(OpARM64MOVWstore)
v.AuxInt = off
v.Aux = sym
v.AuxInt = int32ToAuxInt(off)
v.Aux = symToAux(sym)
v.AddArg3(ptr, x, mem)
return true
}
@ -12884,7 +12916,7 @@ func rewriteValueARM64_OpARM64MOVWstoreidx(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -12976,7 +13008,7 @@ func rewriteValueARM64_OpARM64MOVWstoreidx4(v *Value) bool {
for {
ptr := v_0
idx := v_1
if v_2.Op != OpARM64MOVDconst || v_2.AuxInt != 0 {
if v_2.Op != OpARM64MOVDconst || auxIntToInt64(v_2.AuxInt) != 0 {
break
}
mem := v_3
@ -13066,8 +13098,8 @@ func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVWstorezeroidx ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADD {
break
}
@ -13085,9 +13117,9 @@ func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
// cond: off == 0 && sym == nil
// result: (MOVWstorezeroidx4 ptr idx mem)
for {
off := v.AuxInt
sym := v.Aux
if v_0.Op != OpARM64ADDshiftLL || v_0.AuxInt != 2 {
off := auxIntToInt32(v.AuxInt)
sym := auxToSym(v.Aux)
if v_0.Op != OpARM64ADDshiftLL || auxIntToInt64(v_0.AuxInt) != 2 {
break
}
idx := v_0.Args[1]
@ -13196,30 +13228,38 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezeroidx ptr (MOVDconst [c]) mem)
// result: (MOVWstorezero [c] ptr mem)
// cond: is32Bit(c)
// result: (MOVWstorezero [int32(c)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVWstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(ptr, mem)
return true
}
// match: (MOVWstorezeroidx (MOVDconst [c]) idx mem)
// result: (MOVWstorezero [c] idx mem)
// cond: is32Bit(c)
// result: (MOVWstorezero [int32(c)] idx mem)
for {
if v_0.Op != OpARM64MOVDconst {
break
}
c := v_0.AuxInt
c := auxIntToInt64(v_0.AuxInt)
idx := v_1
mem := v_2
if !(is32Bit(c)) {
break
}
v.reset(OpARM64MOVWstorezero)
v.AuxInt = c
v.AuxInt = int32ToAuxInt(int32(c))
v.AddArg2(idx, mem)
return true
}
@ -13227,7 +13267,7 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx(v *Value) bool {
// result: (MOVWstorezeroidx4 ptr idx mem)
for {
ptr := v_0
if v_1.Op != OpARM64SLLconst || v_1.AuxInt != 2 {
if v_1.Op != OpARM64SLLconst || auxIntToInt64(v_1.AuxInt) != 2 {
break
}
idx := v_1.Args[0]
@ -13239,7 +13279,7 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx(v *Value) bool {
// match: (MOVWstorezeroidx (SLLconst [2] idx) ptr mem)
// result: (MOVWstorezeroidx4 ptr idx mem)
for {
if v_0.Op != OpARM64SLLconst || v_0.AuxInt != 2 {
if v_0.Op != OpARM64SLLconst || auxIntToInt64(v_0.AuxInt) != 2 {
break
}
idx := v_0.Args[0]
@ -13277,16 +13317,20 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx4(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezeroidx4 ptr (MOVDconst [c]) mem)
// result: (MOVWstorezero [c<<2] ptr mem)
// cond: is32Bit(c<<2)
// result: (MOVWstorezero [int32(c<<2)] ptr mem)
for {
ptr := v_0
if v_1.Op != OpARM64MOVDconst {
break
}
c := v_1.AuxInt
c := auxIntToInt64(v_1.AuxInt)
mem := v_2
if !(is32Bit(c << 2)) {
break
}
v.reset(OpARM64MOVWstorezero)
v.AuxInt = c << 2
v.AuxInt = int32ToAuxInt(int32(c << 2))
v.AddArg2(ptr, mem)
return true
}