// match: (ADDB x (MOVBconst [c]))
// cond:
// result: (ADDBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endab690db69bfd8192eea57a2f9f76bf84
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ADDBconst)
v.AddArg(x)
return true
}
- goto endab690db69bfd8192eea57a2f9f76bf84
-endab690db69bfd8192eea57a2f9f76bf84:
- ;
// match: (ADDB (MOVBconst [c]) x)
// cond:
// result: (ADDBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end28aa1a4abe7e1abcdd64135e9967d39d
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end28aa1a4abe7e1abcdd64135e9967d39d
-end28aa1a4abe7e1abcdd64135e9967d39d:
- ;
// match: (ADDB x (NEGB y))
// cond:
// result: (SUBB x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64NEGB {
- goto end9464509b8874ffb00b43b843da01f0bc
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64SUBB)
v.AddArg(y)
return true
}
- goto end9464509b8874ffb00b43b843da01f0bc
-end9464509b8874ffb00b43b843da01f0bc:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDBconst(v *Value, config *Config) bool {
// match: (ADDBconst [c] x)
// cond: int8(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int8(c) == 0) {
- goto end3fbe38dfc1de8f48c755862c4c8b6bac
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end3fbe38dfc1de8f48c755862c4c8b6bac
-end3fbe38dfc1de8f48c755862c4c8b6bac:
- ;
// match: (ADDBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [c+d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = c + d
return true
}
- goto enda9b1e9e31ccdf0af5f4fe57bf4b1343f
-enda9b1e9e31ccdf0af5f4fe57bf4b1343f:
- ;
// match: (ADDBconst [c] (ADDBconst [d] x))
// cond:
// result: (ADDBconst [c+d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64ADDBconst {
- goto end9b1e6890adbf9d9e447d591b4148cbd0
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end9b1e6890adbf9d9e447d591b4148cbd0
-end9b1e6890adbf9d9e447d591b4148cbd0:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDL(v *Value, config *Config) bool {
// match: (ADDL x (MOVLconst [c]))
// cond:
// result: (ADDLconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end8d6d3b99a7be8da6b7a254b7e709cc95
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ADDLconst)
v.AddArg(x)
return true
}
- goto end8d6d3b99a7be8da6b7a254b7e709cc95
-end8d6d3b99a7be8da6b7a254b7e709cc95:
- ;
// match: (ADDL (MOVLconst [c]) x)
// cond:
// result: (ADDLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end739561e08a561e26ce3634dc0d5ec733
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end739561e08a561e26ce3634dc0d5ec733
-end739561e08a561e26ce3634dc0d5ec733:
- ;
// match: (ADDL x (NEGL y))
// cond:
// result: (SUBL x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64NEGL {
- goto end9596df31f2685a49df67c6fb912a521d
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64SUBL)
v.AddArg(y)
return true
}
- goto end9596df31f2685a49df67c6fb912a521d
-end9596df31f2685a49df67c6fb912a521d:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDLconst(v *Value, config *Config) bool {
// match: (ADDLconst [c] x)
// cond: int32(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int32(c) == 0) {
- goto endf04fb6232fbd3b460bb0d1bdcdc57d65
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endf04fb6232fbd3b460bb0d1bdcdc57d65
-endf04fb6232fbd3b460bb0d1bdcdc57d65:
- ;
// match: (ADDLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [c+d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto ende04850e987890abf1d66199042a19c23
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = c + d
return true
}
- goto ende04850e987890abf1d66199042a19c23
-ende04850e987890abf1d66199042a19c23:
- ;
// match: (ADDLconst [c] (ADDLconst [d] x))
// cond:
// result: (ADDLconst [c+d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64ADDLconst {
- goto endf1dd8673b2fef4950aec87aa7523a236
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto endf1dd8673b2fef4950aec87aa7523a236
-endf1dd8673b2fef4950aec87aa7523a236:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDQ(v *Value, config *Config) bool {
// match: (ADDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ADDQconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end1de8aeb1d043e0dadcffd169a99ce5c0
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end1de8aeb1d043e0dadcffd169a99ce5c0
+ break
}
v.reset(OpAMD64ADDQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end1de8aeb1d043e0dadcffd169a99ce5c0
-end1de8aeb1d043e0dadcffd169a99ce5c0:
- ;
// match: (ADDQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (ADDQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endca635e3bdecd9e3aeb892f841021dfaa
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto endca635e3bdecd9e3aeb892f841021dfaa
+ break
}
v.reset(OpAMD64ADDQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto endca635e3bdecd9e3aeb892f841021dfaa
-endca635e3bdecd9e3aeb892f841021dfaa:
- ;
// match: (ADDQ x (SHLQconst [3] y))
// cond:
// result: (LEAQ8 x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64SHLQconst {
- goto endc02313d35a0525d1d680cd58992e820d
+ break
}
if v.Args[1].AuxInt != 3 {
- goto endc02313d35a0525d1d680cd58992e820d
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64LEAQ8)
v.AddArg(y)
return true
}
- goto endc02313d35a0525d1d680cd58992e820d
-endc02313d35a0525d1d680cd58992e820d:
- ;
// match: (ADDQ x (SHLQconst [2] y))
// cond:
// result: (LEAQ4 x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64SHLQconst {
- goto end153955fe292c5ecb20b76bba7da8f451
+ break
}
if v.Args[1].AuxInt != 2 {
- goto end153955fe292c5ecb20b76bba7da8f451
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64LEAQ4)
v.AddArg(y)
return true
}
- goto end153955fe292c5ecb20b76bba7da8f451
-end153955fe292c5ecb20b76bba7da8f451:
- ;
// match: (ADDQ x (SHLQconst [1] y))
// cond:
// result: (LEAQ2 x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64SHLQconst {
- goto enda863d175a7a59f03d4306df57e8351f6
+ break
}
if v.Args[1].AuxInt != 1 {
- goto enda863d175a7a59f03d4306df57e8351f6
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64LEAQ2)
v.AddArg(y)
return true
}
- goto enda863d175a7a59f03d4306df57e8351f6
-enda863d175a7a59f03d4306df57e8351f6:
- ;
// match: (ADDQ x (ADDQ y y))
// cond:
// result: (LEAQ2 x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQ {
- goto endf7dd9841c41eec66eddd351ee39cfbf3
+ break
}
y := v.Args[1].Args[0]
if v.Args[1].Args[1] != y {
- goto endf7dd9841c41eec66eddd351ee39cfbf3
+ break
}
v.reset(OpAMD64LEAQ2)
v.AddArg(x)
v.AddArg(y)
return true
}
- goto endf7dd9841c41eec66eddd351ee39cfbf3
-endf7dd9841c41eec66eddd351ee39cfbf3:
- ;
// match: (ADDQ x (ADDQ x y))
// cond:
// result: (LEAQ2 y x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQ {
- goto end5547794ce29adef7d31260653a56bcb5
+ break
}
if v.Args[1].Args[0] != x {
- goto end5547794ce29adef7d31260653a56bcb5
+ break
}
y := v.Args[1].Args[1]
v.reset(OpAMD64LEAQ2)
v.AddArg(x)
return true
}
- goto end5547794ce29adef7d31260653a56bcb5
-end5547794ce29adef7d31260653a56bcb5:
- ;
// match: (ADDQ x (ADDQ y x))
// cond:
// result: (LEAQ2 y x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQ {
- goto end0ef5fb7590c377b6274991aaea41fae2
+ break
}
y := v.Args[1].Args[0]
if v.Args[1].Args[1] != x {
- goto end0ef5fb7590c377b6274991aaea41fae2
+ break
}
v.reset(OpAMD64LEAQ2)
v.AddArg(y)
v.AddArg(x)
return true
}
- goto end0ef5fb7590c377b6274991aaea41fae2
-end0ef5fb7590c377b6274991aaea41fae2:
- ;
// match: (ADDQ x (LEAQ [c] {s} y))
// cond: x.Op != OpSB && y.Op != OpSB
// result: (LEAQ1 [c] {s} x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64LEAQ {
- goto endadc48e1a7f3d0a3505b68ffc771bb086
+ break
}
c := v.Args[1].AuxInt
s := v.Args[1].Aux
y := v.Args[1].Args[0]
if !(x.Op != OpSB && y.Op != OpSB) {
- goto endadc48e1a7f3d0a3505b68ffc771bb086
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = c
v.AddArg(y)
return true
}
- goto endadc48e1a7f3d0a3505b68ffc771bb086
-endadc48e1a7f3d0a3505b68ffc771bb086:
- ;
// match: (ADDQ (LEAQ [c] {s} x) y)
// cond: x.Op != OpSB && y.Op != OpSB
// result: (LEAQ1 [c] {s} x y)
- {
+ for {
if v.Args[0].Op != OpAMD64LEAQ {
- goto end2696de9ef8f27dbc96dd4ad5878b0779
+ break
}
c := v.Args[0].AuxInt
s := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[1]
if !(x.Op != OpSB && y.Op != OpSB) {
- goto end2696de9ef8f27dbc96dd4ad5878b0779
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = c
v.AddArg(y)
return true
}
- goto end2696de9ef8f27dbc96dd4ad5878b0779
-end2696de9ef8f27dbc96dd4ad5878b0779:
- ;
// match: (ADDQ x (NEGQ y))
// cond:
// result: (SUBQ x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64NEGQ {
- goto endec8f899c6e175a0147a90750f9bfe0a2
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64SUBQ)
v.AddArg(y)
return true
}
- goto endec8f899c6e175a0147a90750f9bfe0a2
-endec8f899c6e175a0147a90750f9bfe0a2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDQconst(v *Value, config *Config) bool {
// match: (ADDQconst [c] (LEAQ [d] {s} x))
// cond:
// result: (LEAQ [c+d] {s} x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64LEAQ {
- goto end5bfebc265098e6e57905269bb95daa3f
+ break
}
d := v.Args[0].AuxInt
s := v.Args[0].Aux
v.AddArg(x)
return true
}
- goto end5bfebc265098e6e57905269bb95daa3f
-end5bfebc265098e6e57905269bb95daa3f:
- ;
// match: (ADDQconst [c] (LEAQ1 [d] {s} x y))
// cond:
// result: (LEAQ1 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64LEAQ1 {
- goto end71505b5ee2217f51c50569efc37499e7
+ break
}
d := v.Args[0].AuxInt
s := v.Args[0].Aux
v.AddArg(y)
return true
}
- goto end71505b5ee2217f51c50569efc37499e7
-end71505b5ee2217f51c50569efc37499e7:
- ;
// match: (ADDQconst [c] (LEAQ2 [d] {s} x y))
// cond:
// result: (LEAQ2 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64LEAQ2 {
- goto end9f155ec07598aec52f602a92a5d719a9
+ break
}
d := v.Args[0].AuxInt
s := v.Args[0].Aux
v.AddArg(y)
return true
}
- goto end9f155ec07598aec52f602a92a5d719a9
-end9f155ec07598aec52f602a92a5d719a9:
- ;
// match: (ADDQconst [c] (LEAQ4 [d] {s} x y))
// cond:
// result: (LEAQ4 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end95f58aac9e8ea7efaef2bec6400cf7f8
+ break
}
d := v.Args[0].AuxInt
s := v.Args[0].Aux
v.AddArg(y)
return true
}
- goto end95f58aac9e8ea7efaef2bec6400cf7f8
-end95f58aac9e8ea7efaef2bec6400cf7f8:
- ;
// match: (ADDQconst [c] (LEAQ8 [d] {s} x y))
// cond:
// result: (LEAQ8 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto end9d4328824aff954a1f47f1109500e826
+ break
}
d := v.Args[0].AuxInt
s := v.Args[0].Aux
v.AddArg(y)
return true
}
- goto end9d4328824aff954a1f47f1109500e826
-end9d4328824aff954a1f47f1109500e826:
- ;
// match: (ADDQconst [0] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto end03d9f5a3e153048b0afa781401e2a849
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end03d9f5a3e153048b0afa781401e2a849
-end03d9f5a3e153048b0afa781401e2a849:
- ;
// match: (ADDQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [c+d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end09dc54395b4e96e8332cf8e4e7481c52
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = c + d
return true
}
- goto end09dc54395b4e96e8332cf8e4e7481c52
-end09dc54395b4e96e8332cf8e4e7481c52:
- ;
// match: (ADDQconst [c] (ADDQconst [d] x))
// cond:
// result: (ADDQconst [c+d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endd4cb539641f0dc40bfd0cb7fbb9b0405
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto endd4cb539641f0dc40bfd0cb7fbb9b0405
-endd4cb539641f0dc40bfd0cb7fbb9b0405:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDW(v *Value, config *Config) bool {
// match: (ADDW x (MOVWconst [c]))
// cond:
// result: (ADDWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end1aabd2317de77c7dfc4876fd7e4c5011
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ADDWconst)
v.AddArg(x)
return true
}
- goto end1aabd2317de77c7dfc4876fd7e4c5011
-end1aabd2317de77c7dfc4876fd7e4c5011:
- ;
// match: (ADDW (MOVWconst [c]) x)
// cond:
// result: (ADDWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto ende3aede99966f388afc624f9e86676fd2
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto ende3aede99966f388afc624f9e86676fd2
-ende3aede99966f388afc624f9e86676fd2:
- ;
// match: (ADDW x (NEGW y))
// cond:
// result: (SUBW x y)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64NEGW {
- goto end55cf2af0d75f3ec413528eeb799e94d5
+ break
}
y := v.Args[1].Args[0]
v.reset(OpAMD64SUBW)
v.AddArg(y)
return true
}
- goto end55cf2af0d75f3ec413528eeb799e94d5
-end55cf2af0d75f3ec413528eeb799e94d5:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ADDWconst(v *Value, config *Config) bool {
// match: (ADDWconst [c] x)
// cond: int16(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int16(c) == 0) {
- goto end8564670ff18b2a91eb92d5e5775464cd
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end8564670ff18b2a91eb92d5e5775464cd
-end8564670ff18b2a91eb92d5e5775464cd:
- ;
// match: (ADDWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [c+d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end32541920f2f5a920dfae41d8ebbef00f
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = c + d
return true
}
- goto end32541920f2f5a920dfae41d8ebbef00f
-end32541920f2f5a920dfae41d8ebbef00f:
- ;
// match: (ADDWconst [c] (ADDWconst [d] x))
// cond:
// result: (ADDWconst [c+d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64ADDWconst {
- goto end73944f6ddda7e4c050f11d17484ff9a5
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end73944f6ddda7e4c050f11d17484ff9a5
-end73944f6ddda7e4c050f11d17484ff9a5:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDB(v *Value, config *Config) bool {
// match: (ANDB x (MOVLconst [c]))
// cond:
// result: (ANDBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end01100cd255396e29bfdb130f4fbc9bbc
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ANDBconst)
v.AddArg(x)
return true
}
- goto end01100cd255396e29bfdb130f4fbc9bbc
-end01100cd255396e29bfdb130f4fbc9bbc:
- ;
// match: (ANDB (MOVLconst [c]) x)
// cond:
// result: (ANDBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end70830ce2834dc5f8d786fa6789460926
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end70830ce2834dc5f8d786fa6789460926
-end70830ce2834dc5f8d786fa6789460926:
- ;
// match: (ANDB x (MOVBconst [c]))
// cond:
// result: (ANDBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endd275ec2e73768cb3d201478fc934e06c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ANDBconst)
v.AddArg(x)
return true
}
- goto endd275ec2e73768cb3d201478fc934e06c
-endd275ec2e73768cb3d201478fc934e06c:
- ;
// match: (ANDB (MOVBconst [c]) x)
// cond:
// result: (ANDBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end4068edac2ae0f354cf581db210288b98
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end4068edac2ae0f354cf581db210288b98
-end4068edac2ae0f354cf581db210288b98:
- ;
// match: (ANDB x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endb8ff272a1456513da708603abe37541c
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endb8ff272a1456513da708603abe37541c
-endb8ff272a1456513da708603abe37541c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDBconst(v *Value, config *Config) bool {
// match: (ANDBconst [c] _)
// cond: int8(c)==0
// result: (MOVBconst [0])
- {
+ for {
c := v.AuxInt
if !(int8(c) == 0) {
- goto end2106d410c949da14d7c00041f40eca76
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end2106d410c949da14d7c00041f40eca76
-end2106d410c949da14d7c00041f40eca76:
- ;
// match: (ANDBconst [c] x)
// cond: int8(c)==-1
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int8(c) == -1) {
- goto enda0b78503c204c8225de1433949a71fe4
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto enda0b78503c204c8225de1433949a71fe4
-enda0b78503c204c8225de1433949a71fe4:
- ;
// match: (ANDBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [c&d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end946312b1f216933da86febe293eb956f
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = c & d
return true
}
- goto end946312b1f216933da86febe293eb956f
-end946312b1f216933da86febe293eb956f:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDL(v *Value, config *Config) bool {
// match: (ANDL x (MOVLconst [c]))
// cond:
// result: (ANDLconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end0a4c49d9a26759c0fd21369dafcd7abb
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ANDLconst)
v.AddArg(x)
return true
}
- goto end0a4c49d9a26759c0fd21369dafcd7abb
-end0a4c49d9a26759c0fd21369dafcd7abb:
- ;
// match: (ANDL (MOVLconst [c]) x)
// cond:
// result: (ANDLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end0529ba323d9b6f15c41add401ef67959
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end0529ba323d9b6f15c41add401ef67959
-end0529ba323d9b6f15c41add401ef67959:
- ;
// match: (ANDL x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto enddfb08a0d0c262854db3905cb323388c7
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto enddfb08a0d0c262854db3905cb323388c7
-enddfb08a0d0c262854db3905cb323388c7:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDLconst(v *Value, config *Config) bool {
// match: (ANDLconst [c] _)
// cond: int32(c)==0
// result: (MOVLconst [0])
- {
+ for {
c := v.AuxInt
if !(int32(c) == 0) {
- goto end5efb241208aef28c950b7bcf8d85d5de
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end5efb241208aef28c950b7bcf8d85d5de
-end5efb241208aef28c950b7bcf8d85d5de:
- ;
// match: (ANDLconst [c] x)
// cond: int32(c)==-1
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int32(c) == -1) {
- goto end0e852ae30bb8289d6ffee0c9267e3e0c
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end0e852ae30bb8289d6ffee0c9267e3e0c
-end0e852ae30bb8289d6ffee0c9267e3e0c:
- ;
// match: (ANDLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [c&d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end7bfd24059369753eadd235f07e2dd7b8
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = c & d
return true
}
- goto end7bfd24059369753eadd235f07e2dd7b8
-end7bfd24059369753eadd235f07e2dd7b8:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDQ(v *Value, config *Config) bool {
// match: (ANDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ANDQconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end048fadc69e81103480015b84b9cafff7
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end048fadc69e81103480015b84b9cafff7
+ break
}
v.reset(OpAMD64ANDQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end048fadc69e81103480015b84b9cafff7
-end048fadc69e81103480015b84b9cafff7:
- ;
// match: (ANDQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (ANDQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end3035a3bf650b708705fd27dd857ab0a4
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto end3035a3bf650b708705fd27dd857ab0a4
+ break
}
v.reset(OpAMD64ANDQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end3035a3bf650b708705fd27dd857ab0a4
-end3035a3bf650b708705fd27dd857ab0a4:
- ;
// match: (ANDQ x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end06b5ec19efdd4e79f03a5e4a2c3c3427
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end06b5ec19efdd4e79f03a5e4a2c3c3427
-end06b5ec19efdd4e79f03a5e4a2c3c3427:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDQconst(v *Value, config *Config) bool {
// match: (ANDQconst [0] _)
// cond:
// result: (MOVQconst [0])
- {
+ for {
if v.AuxInt != 0 {
- goto end57018c1d0f54fd721521095b4832bab2
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto end57018c1d0f54fd721521095b4832bab2
-end57018c1d0f54fd721521095b4832bab2:
- ;
// match: (ANDQconst [-1] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != -1 {
- goto endb542c4b42ab94a7bedb32dec8f610d67
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto endb542c4b42ab94a7bedb32dec8f610d67
-endb542c4b42ab94a7bedb32dec8f610d67:
- ;
// match: (ANDQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [c&d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end67ca66494705b0345a5f22c710225292
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = c & d
return true
}
- goto end67ca66494705b0345a5f22c710225292
-end67ca66494705b0345a5f22c710225292:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDW(v *Value, config *Config) bool {
// match: (ANDW x (MOVLconst [c]))
// cond:
// result: (ANDWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto endce6f557823ee2fdd7a8f47b6f925fc7c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ANDWconst)
v.AddArg(x)
return true
}
- goto endce6f557823ee2fdd7a8f47b6f925fc7c
-endce6f557823ee2fdd7a8f47b6f925fc7c:
- ;
// match: (ANDW (MOVLconst [c]) x)
// cond:
// result: (ANDWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endc46af0d9265c08b09f1f1fba24feda80
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto endc46af0d9265c08b09f1f1fba24feda80
-endc46af0d9265c08b09f1f1fba24feda80:
- ;
// match: (ANDW x (MOVWconst [c]))
// cond:
// result: (ANDWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto enda77a39f65a5eb3436a5842eab69a3103
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ANDWconst)
v.AddArg(x)
return true
}
- goto enda77a39f65a5eb3436a5842eab69a3103
-enda77a39f65a5eb3436a5842eab69a3103:
- ;
// match: (ANDW (MOVWconst [c]) x)
// cond:
// result: (ANDWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto endea2a25eb525a5dbf6d5132d84ea4e7a5
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto endea2a25eb525a5dbf6d5132d84ea4e7a5
-endea2a25eb525a5dbf6d5132d84ea4e7a5:
- ;
// match: (ANDW x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end3a26cf52dd1b77f07cc9e005760dbb11
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end3a26cf52dd1b77f07cc9e005760dbb11
-end3a26cf52dd1b77f07cc9e005760dbb11:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ANDWconst(v *Value, config *Config) bool {
// match: (ANDWconst [c] _)
// cond: int16(c)==0
// result: (MOVWconst [0])
- {
+ for {
c := v.AuxInt
if !(int16(c) == 0) {
- goto end336ece33b4f0fb44dfe1f24981df7b74
+ break
}
v.reset(OpAMD64MOVWconst)
v.AuxInt = 0
return true
}
- goto end336ece33b4f0fb44dfe1f24981df7b74
-end336ece33b4f0fb44dfe1f24981df7b74:
- ;
// match: (ANDWconst [c] x)
// cond: int16(c)==-1
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int16(c) == -1) {
- goto endfb111c3afa8c5c4040fa6000fadee810
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endfb111c3afa8c5c4040fa6000fadee810
-endfb111c3afa8c5c4040fa6000fadee810:
- ;
// match: (ANDWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [c&d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end250eb27fcac10bf6c0d96ce66a21726e
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = c & d
return true
}
- goto end250eb27fcac10bf6c0d96ce66a21726e
-end250eb27fcac10bf6c0d96ce66a21726e:
- ;
return false
}
func rewriteValueAMD64_OpAdd16(v *Value, config *Config) bool {
// match: (Add16 x y)
// cond:
// result: (ADDW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDW)
v.AddArg(y)
return true
}
- goto ende604481c6de9fe4574cb2954ba2ddc67
-ende604481c6de9fe4574cb2954ba2ddc67:
- ;
return false
}
func rewriteValueAMD64_OpAdd32(v *Value, config *Config) bool {
// match: (Add32 x y)
// cond:
// result: (ADDL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDL)
v.AddArg(y)
return true
}
- goto endc445ea2a65385445676cd684ae9a42b5
-endc445ea2a65385445676cd684ae9a42b5:
- ;
return false
}
func rewriteValueAMD64_OpAdd32F(v *Value, config *Config) bool {
// match: (Add32F x y)
// cond:
// result: (ADDSS x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDSS)
v.AddArg(y)
return true
}
- goto end5d82e1c10823774894c036b7c5b8fed4
-end5d82e1c10823774894c036b7c5b8fed4:
- ;
return false
}
func rewriteValueAMD64_OpAdd64(v *Value, config *Config) bool {
// match: (Add64 x y)
// cond:
// result: (ADDQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDQ)
v.AddArg(y)
return true
}
- goto endd88f18b3f39e3ccc201477a616f0abc0
-endd88f18b3f39e3ccc201477a616f0abc0:
- ;
return false
}
func rewriteValueAMD64_OpAdd64F(v *Value, config *Config) bool {
// match: (Add64F x y)
// cond:
// result: (ADDSD x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDSD)
v.AddArg(y)
return true
}
- goto end62f2de6c70abd214e6987ee37976653a
-end62f2de6c70abd214e6987ee37976653a:
- ;
return false
}
func rewriteValueAMD64_OpAdd8(v *Value, config *Config) bool {
// match: (Add8 x y)
// cond:
// result: (ADDB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDB)
v.AddArg(y)
return true
}
- goto end6117c84a6b75c1b816b3fb095bc5f656
-end6117c84a6b75c1b816b3fb095bc5f656:
- ;
return false
}
func rewriteValueAMD64_OpAddPtr(v *Value, config *Config) bool {
// match: (AddPtr x y)
// cond:
// result: (ADDQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ADDQ)
v.AddArg(y)
return true
}
- goto enda1d5640788c7157996f9d4af602dec1c
-enda1d5640788c7157996f9d4af602dec1c:
- ;
return false
}
func rewriteValueAMD64_OpAddr(v *Value, config *Config) bool {
// match: (Addr {sym} base)
// cond:
// result: (LEAQ {sym} base)
- {
+ for {
sym := v.Aux
base := v.Args[0]
v.reset(OpAMD64LEAQ)
v.AddArg(base)
return true
}
- goto end53cad0c3c9daa5575680e77c14e05e72
-end53cad0c3c9daa5575680e77c14e05e72:
- ;
return false
}
func rewriteValueAMD64_OpAnd16(v *Value, config *Config) bool {
// match: (And16 x y)
// cond:
// result: (ANDW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ANDW)
v.AddArg(y)
return true
}
- goto end1c01f04a173d86ce1a6d1ef59e753014
-end1c01f04a173d86ce1a6d1ef59e753014:
- ;
return false
}
func rewriteValueAMD64_OpAnd32(v *Value, config *Config) bool {
// match: (And32 x y)
// cond:
// result: (ANDL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ANDL)
v.AddArg(y)
return true
}
- goto end6b9eb9375b3a859028a6ba6bf6b8ec88
-end6b9eb9375b3a859028a6ba6bf6b8ec88:
- ;
return false
}
func rewriteValueAMD64_OpAnd64(v *Value, config *Config) bool {
// match: (And64 x y)
// cond:
// result: (ANDQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ANDQ)
v.AddArg(y)
return true
}
- goto enda0bde5853819d05fa2b7d3b723629552
-enda0bde5853819d05fa2b7d3b723629552:
- ;
return false
}
func rewriteValueAMD64_OpAnd8(v *Value, config *Config) bool {
// match: (And8 x y)
// cond:
// result: (ANDB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ANDB)
v.AddArg(y)
return true
}
- goto end0f53bee6291f1229b43aa1b5f977b4f2
-end0f53bee6291f1229b43aa1b5f977b4f2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPB(v *Value, config *Config) bool {
// match: (CMPB x (MOVBconst [c]))
// cond:
// result: (CMPBconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end52190c0b8759133aa6c540944965c4c0
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64CMPBconst)
v.AuxInt = c
return true
}
- goto end52190c0b8759133aa6c540944965c4c0
-end52190c0b8759133aa6c540944965c4c0:
- ;
// match: (CMPB (MOVBconst [c]) x)
// cond:
// result: (InvertFlags (CMPBconst x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end25ab646f9eb8749ea58c8fbbb4bf6bcd
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto end25ab646f9eb8749ea58c8fbbb4bf6bcd
-end25ab646f9eb8749ea58c8fbbb4bf6bcd:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPBconst(v *Value, config *Config) bool {
// match: (CMPBconst (MOVBconst [x]) [y])
// cond: int8(x)==int8(y)
// result: (FlagEQ)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end1be300bd80b7d8cd0fa37e1907c75a77
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int8(x) == int8(y)) {
- goto end1be300bd80b7d8cd0fa37e1907c75a77
+ break
}
v.reset(OpAMD64FlagEQ)
return true
}
- goto end1be300bd80b7d8cd0fa37e1907c75a77
-end1be300bd80b7d8cd0fa37e1907c75a77:
- ;
// match: (CMPBconst (MOVBconst [x]) [y])
// cond: int8(x)<int8(y) && uint8(x)<uint8(y)
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endbe76e73088c59765dd0132e2ac15fc6e
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int8(x) < int8(y) && uint8(x) < uint8(y)) {
- goto endbe76e73088c59765dd0132e2ac15fc6e
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto endbe76e73088c59765dd0132e2ac15fc6e
-endbe76e73088c59765dd0132e2ac15fc6e:
- ;
// match: (CMPBconst (MOVBconst [x]) [y])
// cond: int8(x)<int8(y) && uint8(x)>uint8(y)
// result: (FlagLT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endbfa2ca974f69ec9ceb8a24ad6db45efb
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int8(x) < int8(y) && uint8(x) > uint8(y)) {
- goto endbfa2ca974f69ec9ceb8a24ad6db45efb
+ break
}
v.reset(OpAMD64FlagLT_UGT)
return true
}
- goto endbfa2ca974f69ec9ceb8a24ad6db45efb
-endbfa2ca974f69ec9ceb8a24ad6db45efb:
- ;
// match: (CMPBconst (MOVBconst [x]) [y])
// cond: int8(x)>int8(y) && uint8(x)<uint8(y)
// result: (FlagGT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end68ac2e7dcb3704e235e1c292669320ed
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int8(x) > int8(y) && uint8(x) < uint8(y)) {
- goto end68ac2e7dcb3704e235e1c292669320ed
+ break
}
v.reset(OpAMD64FlagGT_ULT)
return true
}
- goto end68ac2e7dcb3704e235e1c292669320ed
-end68ac2e7dcb3704e235e1c292669320ed:
- ;
// match: (CMPBconst (MOVBconst [x]) [y])
// cond: int8(x)>int8(y) && uint8(x)>uint8(y)
// result: (FlagGT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endac1c49c82fb6b76dd324042c4588973c
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int8(x) > int8(y) && uint8(x) > uint8(y)) {
- goto endac1c49c82fb6b76dd324042c4588973c
+ break
}
v.reset(OpAMD64FlagGT_UGT)
return true
}
- goto endac1c49c82fb6b76dd324042c4588973c
-endac1c49c82fb6b76dd324042c4588973c:
- ;
// match: (CMPBconst (ANDBconst _ [m]) [n])
// cond: int8(m)+1==int8(n) && isPowerOfTwo(int64(int8(n)))
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDBconst {
- goto end82aa9d89330cb5dc58592048bfc16ebc
+ break
}
m := v.Args[0].AuxInt
n := v.AuxInt
if !(int8(m)+1 == int8(n) && isPowerOfTwo(int64(int8(n)))) {
- goto end82aa9d89330cb5dc58592048bfc16ebc
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto end82aa9d89330cb5dc58592048bfc16ebc
-end82aa9d89330cb5dc58592048bfc16ebc:
- ;
// match: (CMPBconst (ANDB x y) [0])
// cond:
// result: (TESTB x y)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDB {
- goto endc1dd0adee6d97d0f2644600fa5247db5
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.AuxInt != 0 {
- goto endc1dd0adee6d97d0f2644600fa5247db5
+ break
}
v.reset(OpAMD64TESTB)
v.AddArg(x)
v.AddArg(y)
return true
}
- goto endc1dd0adee6d97d0f2644600fa5247db5
-endc1dd0adee6d97d0f2644600fa5247db5:
- ;
// match: (CMPBconst (ANDBconst [c] x) [0])
// cond:
// result: (TESTBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDBconst {
- goto end575fd7ac1086d0c37e6946db5bbc7e94
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if v.AuxInt != 0 {
- goto end575fd7ac1086d0c37e6946db5bbc7e94
+ break
}
v.reset(OpAMD64TESTBconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end575fd7ac1086d0c37e6946db5bbc7e94
-end575fd7ac1086d0c37e6946db5bbc7e94:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPL(v *Value, config *Config) bool {
// match: (CMPL x (MOVLconst [c]))
// cond:
// result: (CMPLconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end49ff4559c4bdecb2aef0c905e2d9a6cf
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64CMPLconst)
v.AuxInt = c
return true
}
- goto end49ff4559c4bdecb2aef0c905e2d9a6cf
-end49ff4559c4bdecb2aef0c905e2d9a6cf:
- ;
// match: (CMPL (MOVLconst [c]) x)
// cond:
// result: (InvertFlags (CMPLconst x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end7d89230086678ab4ed5cc96a3ae358d6
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto end7d89230086678ab4ed5cc96a3ae358d6
-end7d89230086678ab4ed5cc96a3ae358d6:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPLconst(v *Value, config *Config) bool {
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end7c53f3fc20f710e60f327bf63b4c8d4e
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int32(x) == int32(y)) {
- goto end7c53f3fc20f710e60f327bf63b4c8d4e
+ break
}
v.reset(OpAMD64FlagEQ)
return true
}
- goto end7c53f3fc20f710e60f327bf63b4c8d4e
-end7c53f3fc20f710e60f327bf63b4c8d4e:
- ;
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)<int32(y) && uint32(x)<uint32(y)
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto enda12309892d1f4166bfffc9aa62b37111
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int32(x) < int32(y) && uint32(x) < uint32(y)) {
- goto enda12309892d1f4166bfffc9aa62b37111
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto enda12309892d1f4166bfffc9aa62b37111
-enda12309892d1f4166bfffc9aa62b37111:
- ;
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)<int32(y) && uint32(x)>uint32(y)
// result: (FlagLT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end66603988bfeb71e410328b40425c3418
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int32(x) < int32(y) && uint32(x) > uint32(y)) {
- goto end66603988bfeb71e410328b40425c3418
+ break
}
v.reset(OpAMD64FlagLT_UGT)
return true
}
- goto end66603988bfeb71e410328b40425c3418
-end66603988bfeb71e410328b40425c3418:
- ;
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)>int32(y) && uint32(x)<uint32(y)
// result: (FlagGT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endb1b0b14302e765637328dade12e1ce87
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int32(x) > int32(y) && uint32(x) < uint32(y)) {
- goto endb1b0b14302e765637328dade12e1ce87
+ break
}
v.reset(OpAMD64FlagGT_ULT)
return true
}
- goto endb1b0b14302e765637328dade12e1ce87
-endb1b0b14302e765637328dade12e1ce87:
- ;
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)>int32(y) && uint32(x)>uint32(y)
// result: (FlagGT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endc7b8e86e537d6e106e237023dc2c9a7b
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int32(x) > int32(y) && uint32(x) > uint32(y)) {
- goto endc7b8e86e537d6e106e237023dc2c9a7b
+ break
}
v.reset(OpAMD64FlagGT_UGT)
return true
}
- goto endc7b8e86e537d6e106e237023dc2c9a7b
-endc7b8e86e537d6e106e237023dc2c9a7b:
- ;
// match: (CMPLconst (ANDLconst _ [m]) [n])
// cond: int32(m)+1==int32(n) && isPowerOfTwo(int64(int32(n)))
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDLconst {
- goto endf202b9830a1e45f3888f2598c762c702
+ break
}
m := v.Args[0].AuxInt
n := v.AuxInt
if !(int32(m)+1 == int32(n) && isPowerOfTwo(int64(int32(n)))) {
- goto endf202b9830a1e45f3888f2598c762c702
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto endf202b9830a1e45f3888f2598c762c702
-endf202b9830a1e45f3888f2598c762c702:
- ;
// match: (CMPLconst (ANDL x y) [0])
// cond:
// result: (TESTL x y)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDL {
- goto endc99c55b2fd4bbe4f6eba9675087f215d
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.AuxInt != 0 {
- goto endc99c55b2fd4bbe4f6eba9675087f215d
+ break
}
v.reset(OpAMD64TESTL)
v.AddArg(x)
v.AddArg(y)
return true
}
- goto endc99c55b2fd4bbe4f6eba9675087f215d
-endc99c55b2fd4bbe4f6eba9675087f215d:
- ;
// match: (CMPLconst (ANDLconst [c] x) [0])
// cond:
// result: (TESTLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDLconst {
- goto end218077662043c7cfb0b92334ec8d691f
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if v.AuxInt != 0 {
- goto end218077662043c7cfb0b92334ec8d691f
+ break
}
v.reset(OpAMD64TESTLconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end218077662043c7cfb0b92334ec8d691f
-end218077662043c7cfb0b92334ec8d691f:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPQ(v *Value, config *Config) bool {
// match: (CMPQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (CMPQconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end3bbb2c6caa57853a7561738ce3c0c630
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end3bbb2c6caa57853a7561738ce3c0c630
+ break
}
v.reset(OpAMD64CMPQconst)
v.AddArg(x)
v.AuxInt = c
return true
}
- goto end3bbb2c6caa57853a7561738ce3c0c630
-end3bbb2c6caa57853a7561738ce3c0c630:
- ;
// match: (CMPQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (InvertFlags (CMPQconst x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end153e951c4d9890ee40bf6f189ff6280e
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto end153e951c4d9890ee40bf6f189ff6280e
+ break
}
v.reset(OpAMD64InvertFlags)
v0 := b.NewValue0(v.Line, OpAMD64CMPQconst, TypeFlags)
v.AddArg(v0)
return true
}
- goto end153e951c4d9890ee40bf6f189ff6280e
-end153e951c4d9890ee40bf6f189ff6280e:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPQconst(v *Value, config *Config) bool {
// match: (CMPQconst (MOVQconst [x]) [y])
// cond: x==y
// result: (FlagEQ)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto enda7a434ec055a51246d67ff14b48e455d
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(x == y) {
- goto enda7a434ec055a51246d67ff14b48e455d
+ break
}
v.reset(OpAMD64FlagEQ)
return true
}
- goto enda7a434ec055a51246d67ff14b48e455d
-enda7a434ec055a51246d67ff14b48e455d:
- ;
// match: (CMPQconst (MOVQconst [x]) [y])
// cond: x<y && uint64(x)<uint64(y)
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end88f2277949392f2b8d03934fd812d3ee
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(x < y && uint64(x) < uint64(y)) {
- goto end88f2277949392f2b8d03934fd812d3ee
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto end88f2277949392f2b8d03934fd812d3ee
-end88f2277949392f2b8d03934fd812d3ee:
- ;
// match: (CMPQconst (MOVQconst [x]) [y])
// cond: x<y && uint64(x)>uint64(y)
// result: (FlagLT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end38a2207ac4547f3f0cfb2bc48748e033
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(x < y && uint64(x) > uint64(y)) {
- goto end38a2207ac4547f3f0cfb2bc48748e033
+ break
}
v.reset(OpAMD64FlagLT_UGT)
return true
}
- goto end38a2207ac4547f3f0cfb2bc48748e033
-end38a2207ac4547f3f0cfb2bc48748e033:
- ;
// match: (CMPQconst (MOVQconst [x]) [y])
// cond: x>y && uint64(x)<uint64(y)
// result: (FlagGT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end0adaa13f82a881b97095d7a210b96f3c
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(x > y && uint64(x) < uint64(y)) {
- goto end0adaa13f82a881b97095d7a210b96f3c
+ break
}
v.reset(OpAMD64FlagGT_ULT)
return true
}
- goto end0adaa13f82a881b97095d7a210b96f3c
-end0adaa13f82a881b97095d7a210b96f3c:
- ;
// match: (CMPQconst (MOVQconst [x]) [y])
// cond: x>y && uint64(x)>uint64(y)
// result: (FlagGT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end1248b87e4a141c78bc8eff05d3fac70e
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(x > y && uint64(x) > uint64(y)) {
- goto end1248b87e4a141c78bc8eff05d3fac70e
+ break
}
v.reset(OpAMD64FlagGT_UGT)
return true
}
- goto end1248b87e4a141c78bc8eff05d3fac70e
-end1248b87e4a141c78bc8eff05d3fac70e:
- ;
// match: (CMPQconst (ANDQconst _ [m]) [n])
// cond: m+1==n && isPowerOfTwo(n)
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDQconst {
- goto end934098fb12e383829b654938269abc12
+ break
}
m := v.Args[0].AuxInt
n := v.AuxInt
if !(m+1 == n && isPowerOfTwo(n)) {
- goto end934098fb12e383829b654938269abc12
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto end934098fb12e383829b654938269abc12
-end934098fb12e383829b654938269abc12:
- ;
// match: (CMPQconst (ANDQ x y) [0])
// cond:
// result: (TESTQ x y)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDQ {
- goto endd253b271c624b83def50b061d8a945a1
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.AuxInt != 0 {
- goto endd253b271c624b83def50b061d8a945a1
+ break
}
v.reset(OpAMD64TESTQ)
v.AddArg(x)
v.AddArg(y)
return true
}
- goto endd253b271c624b83def50b061d8a945a1
-endd253b271c624b83def50b061d8a945a1:
- ;
// match: (CMPQconst (ANDQconst [c] x) [0])
// cond:
// result: (TESTQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDQconst {
- goto endcf00c5ad714d2152d72184b163c8d57c
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if v.AuxInt != 0 {
- goto endcf00c5ad714d2152d72184b163c8d57c
+ break
}
v.reset(OpAMD64TESTQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto endcf00c5ad714d2152d72184b163c8d57c
-endcf00c5ad714d2152d72184b163c8d57c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPW(v *Value, config *Config) bool {
// match: (CMPW x (MOVWconst [c]))
// cond:
// result: (CMPWconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end310a9ba58ac35c97587e08c63fe8a46c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64CMPWconst)
v.AuxInt = c
return true
}
- goto end310a9ba58ac35c97587e08c63fe8a46c
-end310a9ba58ac35c97587e08c63fe8a46c:
- ;
// match: (CMPW (MOVWconst [c]) x)
// cond:
// result: (InvertFlags (CMPWconst x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end3c52d0ae6e3d186bf131b41276c21889
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto end3c52d0ae6e3d186bf131b41276c21889
-end3c52d0ae6e3d186bf131b41276c21889:
- ;
return false
}
func rewriteValueAMD64_OpAMD64CMPWconst(v *Value, config *Config) bool {
// match: (CMPWconst (MOVWconst [x]) [y])
// cond: int16(x)==int16(y)
// result: (FlagEQ)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto endff7e81d2095a9997513cae77cd245b43
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int16(x) == int16(y)) {
- goto endff7e81d2095a9997513cae77cd245b43
+ break
}
v.reset(OpAMD64FlagEQ)
return true
}
- goto endff7e81d2095a9997513cae77cd245b43
-endff7e81d2095a9997513cae77cd245b43:
- ;
// match: (CMPWconst (MOVWconst [x]) [y])
// cond: int16(x)<int16(y) && uint16(x)<uint16(y)
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end13137b0dee5a1ef5d508b312e4fa947c
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int16(x) < int16(y) && uint16(x) < uint16(y)) {
- goto end13137b0dee5a1ef5d508b312e4fa947c
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto end13137b0dee5a1ef5d508b312e4fa947c
-end13137b0dee5a1ef5d508b312e4fa947c:
- ;
// match: (CMPWconst (MOVWconst [x]) [y])
// cond: int16(x)<int16(y) && uint16(x)>uint16(y)
// result: (FlagLT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto ended901a2a49e592c431e45ffc17ca213d
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int16(x) < int16(y) && uint16(x) > uint16(y)) {
- goto ended901a2a49e592c431e45ffc17ca213d
+ break
}
v.reset(OpAMD64FlagLT_UGT)
return true
}
- goto ended901a2a49e592c431e45ffc17ca213d
-ended901a2a49e592c431e45ffc17ca213d:
- ;
// match: (CMPWconst (MOVWconst [x]) [y])
// cond: int16(x)>int16(y) && uint16(x)<uint16(y)
// result: (FlagGT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end66b1d55596a00cdc04ad83bfdeb6be8b
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int16(x) > int16(y) && uint16(x) < uint16(y)) {
- goto end66b1d55596a00cdc04ad83bfdeb6be8b
+ break
}
v.reset(OpAMD64FlagGT_ULT)
return true
}
- goto end66b1d55596a00cdc04ad83bfdeb6be8b
-end66b1d55596a00cdc04ad83bfdeb6be8b:
- ;
// match: (CMPWconst (MOVWconst [x]) [y])
// cond: int16(x)>int16(y) && uint16(x)>uint16(y)
// result: (FlagGT_UGT)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end4493f5af38d242ebb4bc2f64055a0854
+ break
}
x := v.Args[0].AuxInt
y := v.AuxInt
if !(int16(x) > int16(y) && uint16(x) > uint16(y)) {
- goto end4493f5af38d242ebb4bc2f64055a0854
+ break
}
v.reset(OpAMD64FlagGT_UGT)
return true
}
- goto end4493f5af38d242ebb4bc2f64055a0854
-end4493f5af38d242ebb4bc2f64055a0854:
- ;
// match: (CMPWconst (ANDWconst _ [m]) [n])
// cond: int16(m)+1==int16(n) && isPowerOfTwo(int64(int16(n)))
// result: (FlagLT_ULT)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDWconst {
- goto endfcea07d93ded49b0e02d5fa0059309a4
+ break
}
m := v.Args[0].AuxInt
n := v.AuxInt
if !(int16(m)+1 == int16(n) && isPowerOfTwo(int64(int16(n)))) {
- goto endfcea07d93ded49b0e02d5fa0059309a4
+ break
}
v.reset(OpAMD64FlagLT_ULT)
return true
}
- goto endfcea07d93ded49b0e02d5fa0059309a4
-endfcea07d93ded49b0e02d5fa0059309a4:
- ;
// match: (CMPWconst (ANDW x y) [0])
// cond:
// result: (TESTW x y)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDW {
- goto end390cbc150fec59cbf63a209c485ef8b2
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.AuxInt != 0 {
- goto end390cbc150fec59cbf63a209c485ef8b2
+ break
}
v.reset(OpAMD64TESTW)
v.AddArg(x)
v.AddArg(y)
return true
}
- goto end390cbc150fec59cbf63a209c485ef8b2
-end390cbc150fec59cbf63a209c485ef8b2:
- ;
// match: (CMPWconst (ANDWconst [c] x) [0])
// cond:
// result: (TESTWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDWconst {
- goto end1bde0fea3dcffeb66b314bc6b4c9aae5
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if v.AuxInt != 0 {
- goto end1bde0fea3dcffeb66b314bc6b4c9aae5
+ break
}
v.reset(OpAMD64TESTWconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end1bde0fea3dcffeb66b314bc6b4c9aae5
-end1bde0fea3dcffeb66b314bc6b4c9aae5:
- ;
return false
}
func rewriteValueAMD64_OpClosureCall(v *Value, config *Config) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
- {
+ for {
argwid := v.AuxInt
entry := v.Args[0]
closure := v.Args[1]
v.AddArg(mem)
return true
}
- goto endfd75d26316012d86cb71d0dd1214259b
-endfd75d26316012d86cb71d0dd1214259b:
- ;
return false
}
func rewriteValueAMD64_OpCom16(v *Value, config *Config) bool {
// match: (Com16 x)
// cond:
// result: (NOTW x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NOTW)
v.AddArg(x)
return true
}
- goto end1b14ba8d7d7aa585ec0a211827f280ae
-end1b14ba8d7d7aa585ec0a211827f280ae:
- ;
return false
}
func rewriteValueAMD64_OpCom32(v *Value, config *Config) bool {
// match: (Com32 x)
// cond:
// result: (NOTL x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NOTL)
v.AddArg(x)
return true
}
- goto end6eb124ba3bdb3fd6031414370852feb6
-end6eb124ba3bdb3fd6031414370852feb6:
- ;
return false
}
func rewriteValueAMD64_OpCom64(v *Value, config *Config) bool {
// match: (Com64 x)
// cond:
// result: (NOTQ x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NOTQ)
v.AddArg(x)
return true
}
- goto endf5f3b355a87779c347e305719dddda05
-endf5f3b355a87779c347e305719dddda05:
- ;
return false
}
func rewriteValueAMD64_OpCom8(v *Value, config *Config) bool {
// match: (Com8 x)
// cond:
// result: (NOTB x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NOTB)
v.AddArg(x)
return true
}
- goto end1c7c5c055d663ccf1f05fbc4883030c6
-end1c7c5c055d663ccf1f05fbc4883030c6:
- ;
return false
}
func rewriteValueAMD64_OpConst16(v *Value, config *Config) bool {
// match: (Const16 [val])
// cond:
// result: (MOVWconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = val
return true
}
- goto end2c6c92f297873b8ac12bd035d56d001e
-end2c6c92f297873b8ac12bd035d56d001e:
- ;
return false
}
func rewriteValueAMD64_OpConst32(v *Value, config *Config) bool {
// match: (Const32 [val])
// cond:
// result: (MOVLconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = val
return true
}
- goto enddae5807662af67143a3ac3ad9c63bae5
-enddae5807662af67143a3ac3ad9c63bae5:
- ;
return false
}
func rewriteValueAMD64_OpConst32F(v *Value, config *Config) bool {
// match: (Const32F [val])
// cond:
// result: (MOVSSconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVSSconst)
v.AuxInt = val
return true
}
- goto endfabcef2d57a8f36eaa6041de6f112b89
-endfabcef2d57a8f36eaa6041de6f112b89:
- ;
return false
}
func rewriteValueAMD64_OpConst64(v *Value, config *Config) bool {
// match: (Const64 [val])
// cond:
// result: (MOVQconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = val
return true
}
- goto endc630434ae7f143ab69d5f482a9b52b5f
-endc630434ae7f143ab69d5f482a9b52b5f:
- ;
return false
}
func rewriteValueAMD64_OpConst64F(v *Value, config *Config) bool {
// match: (Const64F [val])
// cond:
// result: (MOVSDconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVSDconst)
v.AuxInt = val
return true
}
- goto endae6cf7189e464bbde17b98635a20f0ff
-endae6cf7189e464bbde17b98635a20f0ff:
- ;
return false
}
func rewriteValueAMD64_OpConst8(v *Value, config *Config) bool {
// match: (Const8 [val])
// cond:
// result: (MOVBconst [val])
- {
+ for {
val := v.AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = val
return true
}
- goto end200524c722ed14ca935ba47f8f30327d
-end200524c722ed14ca935ba47f8f30327d:
- ;
return false
}
func rewriteValueAMD64_OpConstBool(v *Value, config *Config) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVBconst [b])
- {
+ for {
b := v.AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = b
return true
}
- goto end6d919011283330dcbcb3826f0adc6793
-end6d919011283330dcbcb3826f0adc6793:
- ;
return false
}
func rewriteValueAMD64_OpConstNil(v *Value, config *Config) bool {
// match: (ConstNil)
// cond:
// result: (MOVQconst [0])
- {
+ for {
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto endea557d921056c25b945a49649e4b9b91
-endea557d921056c25b945a49649e4b9b91:
- ;
return false
}
func rewriteValueAMD64_OpConvert(v *Value, config *Config) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVQconvert <t> x mem)
- {
+ for {
t := v.Type
x := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto end0aa5cd28888761ffab21bce45db361c8
-end0aa5cd28888761ffab21bce45db361c8:
- ;
return false
}
func rewriteValueAMD64_OpCvt32Fto32(v *Value, config *Config) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CVTTSS2SL x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTTSS2SL)
v.AddArg(x)
return true
}
- goto enda410209d31804e1bce7bdc235fc62342
-enda410209d31804e1bce7bdc235fc62342:
- ;
return false
}
func rewriteValueAMD64_OpCvt32Fto64(v *Value, config *Config) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (CVTTSS2SQ x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTTSS2SQ)
v.AddArg(x)
return true
}
- goto enddb02fa4f3230a14d557d6c90cdadd523
-enddb02fa4f3230a14d557d6c90cdadd523:
- ;
return false
}
func rewriteValueAMD64_OpCvt32Fto64F(v *Value, config *Config) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (CVTSS2SD x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSS2SD)
v.AddArg(x)
return true
}
- goto end0bf5d6f8d182ee2b3ab7d7c2f8ff7790
-end0bf5d6f8d182ee2b3ab7d7c2f8ff7790:
- ;
return false
}
func rewriteValueAMD64_OpCvt32to32F(v *Value, config *Config) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CVTSL2SS x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSL2SS)
v.AddArg(x)
return true
}
- goto ende0bdea2b21aecdb8399d6fd80ddc97d6
-ende0bdea2b21aecdb8399d6fd80ddc97d6:
- ;
return false
}
func rewriteValueAMD64_OpCvt32to64F(v *Value, config *Config) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CVTSL2SD x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSL2SD)
v.AddArg(x)
return true
}
- goto ende06cbe745112bcf0e6612788ef71c958
-ende06cbe745112bcf0e6612788ef71c958:
- ;
return false
}
func rewriteValueAMD64_OpCvt64Fto32(v *Value, config *Config) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CVTTSD2SL x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTTSD2SL)
v.AddArg(x)
return true
}
- goto endc213dd690dfe568607dec717b2c385b7
-endc213dd690dfe568607dec717b2c385b7:
- ;
return false
}
func rewriteValueAMD64_OpCvt64Fto32F(v *Value, config *Config) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (CVTSD2SS x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSD2SS)
v.AddArg(x)
return true
}
- goto endfd70158a96824ced99712d606c607d94
-endfd70158a96824ced99712d606c607d94:
- ;
return false
}
func rewriteValueAMD64_OpCvt64Fto64(v *Value, config *Config) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (CVTTSD2SQ x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTTSD2SQ)
v.AddArg(x)
return true
}
- goto end0bf3e4468047fd20714266ff05797454
-end0bf3e4468047fd20714266ff05797454:
- ;
return false
}
func rewriteValueAMD64_OpCvt64to32F(v *Value, config *Config) bool {
// match: (Cvt64to32F x)
// cond:
// result: (CVTSQ2SS x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSQ2SS)
v.AddArg(x)
return true
}
- goto endfecc08b8a8cbd2bf3be21a077c4d0d40
-endfecc08b8a8cbd2bf3be21a077c4d0d40:
- ;
return false
}
func rewriteValueAMD64_OpCvt64to64F(v *Value, config *Config) bool {
// match: (Cvt64to64F x)
// cond:
// result: (CVTSQ2SD x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64CVTSQ2SD)
v.AddArg(x)
return true
}
- goto endf74ce5df659f385f75c61187b515a5d0
-endf74ce5df659f385f75c61187b515a5d0:
- ;
return false
}
func rewriteValueAMD64_OpDeferCall(v *Value, config *Config) bool {
// match: (DeferCall [argwid] mem)
// cond:
// result: (CALLdefer [argwid] mem)
- {
+ for {
argwid := v.AuxInt
mem := v.Args[0]
v.reset(OpAMD64CALLdefer)
v.AddArg(mem)
return true
}
- goto end1c408581037450df959dd1fb7554a022
-end1c408581037450df959dd1fb7554a022:
- ;
return false
}
func rewriteValueAMD64_OpDiv16(v *Value, config *Config) bool {
// match: (Div16 x y)
// cond:
// result: (DIVW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVW)
v.AddArg(y)
return true
}
- goto endb60a86e606726640c84d3e1e5a5ce890
-endb60a86e606726640c84d3e1e5a5ce890:
- ;
return false
}
func rewriteValueAMD64_OpDiv16u(v *Value, config *Config) bool {
// match: (Div16u x y)
// cond:
// result: (DIVWU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVWU)
v.AddArg(y)
return true
}
- goto end6af9e212a865593e506bfdf7db67c9ec
-end6af9e212a865593e506bfdf7db67c9ec:
- ;
return false
}
func rewriteValueAMD64_OpDiv32(v *Value, config *Config) bool {
// match: (Div32 x y)
// cond:
// result: (DIVL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVL)
v.AddArg(y)
return true
}
- goto endf20ac71407e57c2904684d3cc33cf697
-endf20ac71407e57c2904684d3cc33cf697:
- ;
return false
}
func rewriteValueAMD64_OpDiv32F(v *Value, config *Config) bool {
// match: (Div32F x y)
// cond:
// result: (DIVSS x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVSS)
v.AddArg(y)
return true
}
- goto enddca0462c7b176c4138854d7d5627ab5b
-enddca0462c7b176c4138854d7d5627ab5b:
- ;
return false
}
func rewriteValueAMD64_OpDiv32u(v *Value, config *Config) bool {
// match: (Div32u x y)
// cond:
// result: (DIVLU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVLU)
v.AddArg(y)
return true
}
- goto enda22604d23eeb1298008c97b817f60bbd
-enda22604d23eeb1298008c97b817f60bbd:
- ;
return false
}
func rewriteValueAMD64_OpDiv64(v *Value, config *Config) bool {
// match: (Div64 x y)
// cond:
// result: (DIVQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVQ)
v.AddArg(y)
return true
}
- goto end86490d9b337333dfc09a413e1e0120a9
-end86490d9b337333dfc09a413e1e0120a9:
- ;
return false
}
func rewriteValueAMD64_OpDiv64F(v *Value, config *Config) bool {
// match: (Div64F x y)
// cond:
// result: (DIVSD x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVSD)
v.AddArg(y)
return true
}
- goto end12299d76db5144a60f564d34ba97eb43
-end12299d76db5144a60f564d34ba97eb43:
- ;
return false
}
func rewriteValueAMD64_OpDiv64u(v *Value, config *Config) bool {
// match: (Div64u x y)
// cond:
// result: (DIVQU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVQU)
v.AddArg(y)
return true
}
- goto endf871d8b397e5fad6a5b500cc0c759a8d
-endf871d8b397e5fad6a5b500cc0c759a8d:
- ;
return false
}
func rewriteValueAMD64_OpDiv8(v *Value, config *Config) bool {
// match: (Div8 x y)
// cond:
// result: (DIVW (SignExt8to16 x) (SignExt8to16 y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVW)
v.AddArg(v1)
return true
}
- goto endeee2bc780a73ec2ccb1a66c527816ee0
-endeee2bc780a73ec2ccb1a66c527816ee0:
- ;
return false
}
func rewriteValueAMD64_OpDiv8u(v *Value, config *Config) bool {
// match: (Div8u x y)
// cond:
// result: (DIVWU (ZeroExt8to16 x) (ZeroExt8to16 y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64DIVWU)
v.AddArg(v1)
return true
}
- goto end39da6664d6434d844303f6924cc875dd
-end39da6664d6434d844303f6924cc875dd:
- ;
return false
}
func rewriteValueAMD64_OpEq16(v *Value, config *Config) bool {
// match: (Eq16 x y)
// cond:
// result: (SETEQ (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQ)
v.AddArg(v0)
return true
}
- goto endd7f668b1d23603b0949953ee8dec8107
-endd7f668b1d23603b0949953ee8dec8107:
- ;
return false
}
func rewriteValueAMD64_OpEq32(v *Value, config *Config) bool {
// match: (Eq32 x y)
// cond:
// result: (SETEQ (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQ)
v.AddArg(v0)
return true
}
- goto endf28041ae0c73fb341cc0d2f4903fb2fb
-endf28041ae0c73fb341cc0d2f4903fb2fb:
- ;
return false
}
func rewriteValueAMD64_OpEq32F(v *Value, config *Config) bool {
// match: (Eq32F x y)
// cond:
// result: (SETEQF (UCOMISS x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQF)
v.AddArg(v0)
return true
}
- goto endb2c12933769e5faa8fc238048e113dee
-endb2c12933769e5faa8fc238048e113dee:
- ;
return false
}
func rewriteValueAMD64_OpEq64(v *Value, config *Config) bool {
// match: (Eq64 x y)
// cond:
// result: (SETEQ (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQ)
v.AddArg(v0)
return true
}
- goto ende07a380487b710b51bcd5aa6d3144b8c
-ende07a380487b710b51bcd5aa6d3144b8c:
- ;
return false
}
func rewriteValueAMD64_OpEq64F(v *Value, config *Config) bool {
// match: (Eq64F x y)
// cond:
// result: (SETEQF (UCOMISD x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQF)
v.AddArg(v0)
return true
}
- goto end68e20c0c1b3ee62fbd17af07ac100704
-end68e20c0c1b3ee62fbd17af07ac100704:
- ;
return false
}
func rewriteValueAMD64_OpEq8(v *Value, config *Config) bool {
// match: (Eq8 x y)
// cond:
// result: (SETEQ (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQ)
v.AddArg(v0)
return true
}
- goto end359e5a51d2ab928a455f0ae5adb42ab0
-end359e5a51d2ab928a455f0ae5adb42ab0:
- ;
return false
}
func rewriteValueAMD64_OpEqPtr(v *Value, config *Config) bool {
// match: (EqPtr x y)
// cond:
// result: (SETEQ (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETEQ)
v.AddArg(v0)
return true
}
- goto endf19bd3c0eb99d15718bef4066d62560c
-endf19bd3c0eb99d15718bef4066d62560c:
- ;
return false
}
func rewriteValueAMD64_OpGeq16(v *Value, config *Config) bool {
// match: (Geq16 x y)
// cond:
// result: (SETGE (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGE)
v.AddArg(v0)
return true
}
- goto end0a3f723d5c0b877c473b0043d814867b
-end0a3f723d5c0b877c473b0043d814867b:
- ;
return false
}
func rewriteValueAMD64_OpGeq16U(v *Value, config *Config) bool {
// match: (Geq16U x y)
// cond:
// result: (SETAE (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETAE)
v.AddArg(v0)
return true
}
- goto end79d754a28ee34eff95140635b26f0248
-end79d754a28ee34eff95140635b26f0248:
- ;
return false
}
func rewriteValueAMD64_OpGeq32(v *Value, config *Config) bool {
// match: (Geq32 x y)
// cond:
// result: (SETGE (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGE)
v.AddArg(v0)
return true
}
- goto endfb1f6286a1b153b2a3f5b8548a782c8c
-endfb1f6286a1b153b2a3f5b8548a782c8c:
- ;
return false
}
func rewriteValueAMD64_OpGeq32F(v *Value, config *Config) bool {
// match: (Geq32F x y)
// cond:
// result: (SETGEF (UCOMISS x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGEF)
v.AddArg(v0)
return true
}
- goto end7a8d6107a945410e64db06669a61da97
-end7a8d6107a945410e64db06669a61da97:
- ;
return false
}
func rewriteValueAMD64_OpGeq32U(v *Value, config *Config) bool {
// match: (Geq32U x y)
// cond:
// result: (SETAE (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETAE)
v.AddArg(v0)
return true
}
- goto endc5d3478a626df01ede063564f4cb80d0
-endc5d3478a626df01ede063564f4cb80d0:
- ;
return false
}
func rewriteValueAMD64_OpGeq64(v *Value, config *Config) bool {
// match: (Geq64 x y)
// cond:
// result: (SETGE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGE)
v.AddArg(v0)
return true
}
- goto end74bddb7905ab865de5b041e7e4789911
-end74bddb7905ab865de5b041e7e4789911:
- ;
return false
}
func rewriteValueAMD64_OpGeq64F(v *Value, config *Config) bool {
// match: (Geq64F x y)
// cond:
// result: (SETGEF (UCOMISD x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGEF)
v.AddArg(v0)
return true
}
- goto end9fac9bd98ef58b7fbbe1a31f84bdcccf
-end9fac9bd98ef58b7fbbe1a31f84bdcccf:
- ;
return false
}
func rewriteValueAMD64_OpGeq64U(v *Value, config *Config) bool {
// match: (Geq64U x y)
// cond:
// result: (SETAE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETAE)
v.AddArg(v0)
return true
}
- goto end95101721fc8f5be9969e50e364143e7f
-end95101721fc8f5be9969e50e364143e7f:
- ;
return false
}
func rewriteValueAMD64_OpGeq8(v *Value, config *Config) bool {
// match: (Geq8 x y)
// cond:
// result: (SETGE (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGE)
v.AddArg(v0)
return true
}
- goto end983070a3db317bdb64b5a0fb104d267c
-end983070a3db317bdb64b5a0fb104d267c:
- ;
return false
}
func rewriteValueAMD64_OpGeq8U(v *Value, config *Config) bool {
// match: (Geq8U x y)
// cond:
// result: (SETAE (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETAE)
v.AddArg(v0)
return true
}
- goto enda617119faaccc0f0c2d23548116cf331
-enda617119faaccc0f0c2d23548116cf331:
- ;
return false
}
func rewriteValueAMD64_OpGetClosurePtr(v *Value, config *Config) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
- {
+ for {
v.reset(OpAMD64LoweredGetClosurePtr)
return true
}
- goto end6fd0b53f0acb4d35e7d7fa78d2ca1392
-end6fd0b53f0acb4d35e7d7fa78d2ca1392:
- ;
return false
}
func rewriteValueAMD64_OpGetG(v *Value, config *Config) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
- {
+ for {
mem := v.Args[0]
v.reset(OpAMD64LoweredGetG)
v.AddArg(mem)
return true
}
- goto endf543eaaf68c4bef1d4cdc8ba19683723
-endf543eaaf68c4bef1d4cdc8ba19683723:
- ;
return false
}
func rewriteValueAMD64_OpGoCall(v *Value, config *Config) bool {
// match: (GoCall [argwid] mem)
// cond:
// result: (CALLgo [argwid] mem)
- {
+ for {
argwid := v.AuxInt
mem := v.Args[0]
v.reset(OpAMD64CALLgo)
v.AddArg(mem)
return true
}
- goto end1cef0f92c46e6aaa2c7abdf5f2794baf
-end1cef0f92c46e6aaa2c7abdf5f2794baf:
- ;
return false
}
func rewriteValueAMD64_OpGreater16(v *Value, config *Config) bool {
// match: (Greater16 x y)
// cond:
// result: (SETG (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETG)
v.AddArg(v0)
return true
}
- goto end4e4a1307c61240af9a86d8fe4f834ee8
-end4e4a1307c61240af9a86d8fe4f834ee8:
- ;
return false
}
func rewriteValueAMD64_OpGreater16U(v *Value, config *Config) bool {
// match: (Greater16U x y)
// cond:
// result: (SETA (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETA)
v.AddArg(v0)
return true
}
- goto end7c66c75f4b8ec1db593f3e60cfba9592
-end7c66c75f4b8ec1db593f3e60cfba9592:
- ;
return false
}
func rewriteValueAMD64_OpGreater32(v *Value, config *Config) bool {
// match: (Greater32 x y)
// cond:
// result: (SETG (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETG)
v.AddArg(v0)
return true
}
- goto end6fb0eae4a0e0e81b4afb085d398d873b
-end6fb0eae4a0e0e81b4afb085d398d873b:
- ;
return false
}
func rewriteValueAMD64_OpGreater32F(v *Value, config *Config) bool {
// match: (Greater32F x y)
// cond:
// result: (SETGF (UCOMISS x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGF)
v.AddArg(v0)
return true
}
- goto end94df0bd5cedad8ce8021df1b24da40c6
-end94df0bd5cedad8ce8021df1b24da40c6:
- ;
return false
}
func rewriteValueAMD64_OpGreater32U(v *Value, config *Config) bool {
// match: (Greater32U x y)
// cond:
// result: (SETA (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETA)
v.AddArg(v0)
return true
}
- goto end18da022a28eae8bd0771e0c948aadaf8
-end18da022a28eae8bd0771e0c948aadaf8:
- ;
return false
}
func rewriteValueAMD64_OpGreater64(v *Value, config *Config) bool {
// match: (Greater64 x y)
// cond:
// result: (SETG (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETG)
v.AddArg(v0)
return true
}
- goto endc025c908708f939780fba0da0c1148b4
-endc025c908708f939780fba0da0c1148b4:
- ;
return false
}
func rewriteValueAMD64_OpGreater64F(v *Value, config *Config) bool {
// match: (Greater64F x y)
// cond:
// result: (SETGF (UCOMISD x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGF)
v.AddArg(v0)
return true
}
- goto end033ca5181b18376e7215c02812ef5a6b
-end033ca5181b18376e7215c02812ef5a6b:
- ;
return false
}
func rewriteValueAMD64_OpGreater64U(v *Value, config *Config) bool {
// match: (Greater64U x y)
// cond:
// result: (SETA (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETA)
v.AddArg(v0)
return true
}
- goto endb3e25347041760a04d3fc8321c3f3d00
-endb3e25347041760a04d3fc8321c3f3d00:
- ;
return false
}
func rewriteValueAMD64_OpGreater8(v *Value, config *Config) bool {
// match: (Greater8 x y)
// cond:
// result: (SETG (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETG)
v.AddArg(v0)
return true
}
- goto enda3eeb5da2e69cb54a1515601d4b360d4
-enda3eeb5da2e69cb54a1515601d4b360d4:
- ;
return false
}
func rewriteValueAMD64_OpGreater8U(v *Value, config *Config) bool {
// match: (Greater8U x y)
// cond:
// result: (SETA (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETA)
v.AddArg(v0)
return true
}
- goto endd2027f3b6471262f42b90c8cc0413667
-endd2027f3b6471262f42b90c8cc0413667:
- ;
return false
}
func rewriteValueAMD64_OpHmul16(v *Value, config *Config) bool {
// match: (Hmul16 x y)
// cond:
// result: (HMULW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULW)
v.AddArg(y)
return true
}
- goto end1b9ff394bb3b06fc109637656b6875f5
-end1b9ff394bb3b06fc109637656b6875f5:
- ;
return false
}
func rewriteValueAMD64_OpHmul16u(v *Value, config *Config) bool {
// match: (Hmul16u x y)
// cond:
// result: (HMULWU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULWU)
v.AddArg(y)
return true
}
- goto endee9089e794a43f2ce1619a6ef61670f4
-endee9089e794a43f2ce1619a6ef61670f4:
- ;
return false
}
func rewriteValueAMD64_OpHmul32(v *Value, config *Config) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMULL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULL)
v.AddArg(y)
return true
}
- goto end7c83c91ef2634f0b1da4f49350b437b1
-end7c83c91ef2634f0b1da4f49350b437b1:
- ;
return false
}
func rewriteValueAMD64_OpHmul32u(v *Value, config *Config) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULLU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULLU)
v.AddArg(y)
return true
}
- goto end3c4f36611dc8815aa2a63d4ec0eaa06d
-end3c4f36611dc8815aa2a63d4ec0eaa06d:
- ;
return false
}
func rewriteValueAMD64_OpHmul8(v *Value, config *Config) bool {
// match: (Hmul8 x y)
// cond:
// result: (HMULB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULB)
v.AddArg(y)
return true
}
- goto end51b2cc9f1ed15314e68fc81024f281a7
-end51b2cc9f1ed15314e68fc81024f281a7:
- ;
return false
}
func rewriteValueAMD64_OpHmul8u(v *Value, config *Config) bool {
// match: (Hmul8u x y)
// cond:
// result: (HMULBU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64HMULBU)
v.AddArg(y)
return true
}
- goto ende68d7b3a3c774cedc3522af9d635c39d
-ende68d7b3a3c774cedc3522af9d635c39d:
- ;
return false
}
func rewriteValueAMD64_OpITab(v *Value, config *Config) bool {
// match: (ITab (Load ptr mem))
// cond:
// result: (MOVQload ptr mem)
- {
+ for {
if v.Args[0].Op != OpLoad {
- goto enda49fcae3630a097c78aa58189c90a97a
+ break
}
ptr := v.Args[0].Args[0]
mem := v.Args[0].Args[1]
v.AddArg(mem)
return true
}
- goto enda49fcae3630a097c78aa58189c90a97a
-enda49fcae3630a097c78aa58189c90a97a:
- ;
return false
}
func rewriteValueAMD64_OpInterCall(v *Value, config *Config) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
- {
+ for {
argwid := v.AuxInt
entry := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto endc04351e492ed362efc6aa75121bca305
-endc04351e492ed362efc6aa75121bca305:
- ;
return false
}
func rewriteValueAMD64_OpIsInBounds(v *Value, config *Config) bool {
// match: (IsInBounds idx len)
// cond:
// result: (SETB (CMPQ idx len))
- {
+ for {
idx := v.Args[0]
len := v.Args[1]
v.reset(OpAMD64SETB)
v.AddArg(v0)
return true
}
- goto endfff988d5f1912886d73be3bb563c37d9
-endfff988d5f1912886d73be3bb563c37d9:
- ;
return false
}
func rewriteValueAMD64_OpIsNonNil(v *Value, config *Config) bool {
// match: (IsNonNil p)
// cond:
// result: (SETNE (TESTQ p p))
- {
+ for {
p := v.Args[0]
v.reset(OpAMD64SETNE)
v0 := b.NewValue0(v.Line, OpAMD64TESTQ, TypeFlags)
v.AddArg(v0)
return true
}
- goto end0af5ec868ede9ea73fb0602d54b863e9
-end0af5ec868ede9ea73fb0602d54b863e9:
- ;
return false
}
func rewriteValueAMD64_OpIsSliceInBounds(v *Value, config *Config) bool {
// match: (IsSliceInBounds idx len)
// cond:
// result: (SETBE (CMPQ idx len))
- {
+ for {
idx := v.Args[0]
len := v.Args[1]
v.reset(OpAMD64SETBE)
v.AddArg(v0)
return true
}
- goto end02799ad95fe7fb5ce3c2c8ab313b737c
-end02799ad95fe7fb5ce3c2c8ab313b737c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64LEAQ(v *Value, config *Config) bool {
// match: (LEAQ [c] {s} (ADDQconst [d] x))
// cond:
// result: (LEAQ [c+d] {s} x)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endb764d049517eb7c125b442ec9246c2c6
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto endb764d049517eb7c125b442ec9246c2c6
-endb764d049517eb7c125b442ec9246c2c6:
- ;
// match: (LEAQ [c] {s} (ADDQ x y))
// cond: x.Op != OpSB && y.Op != OpSB
// result: (LEAQ1 [c] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQ {
- goto end8ee88dfb1a197184ebe10e479fafd322
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if !(x.Op != OpSB && y.Op != OpSB) {
- goto end8ee88dfb1a197184ebe10e479fafd322
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = c
v.AddArg(y)
return true
}
- goto end8ee88dfb1a197184ebe10e479fafd322
-end8ee88dfb1a197184ebe10e479fafd322:
- ;
// match: (LEAQ [off1] {sym1} (LEAQ [off2] {sym2} x))
// cond: canMergeSym(sym1, sym2)
// result: (LEAQ [addOff(off1,off2)] {mergeSym(sym1,sym2)} x)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end2e2249051d6776a92bcb0d83107e0d82
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
if !(canMergeSym(sym1, sym2)) {
- goto end2e2249051d6776a92bcb0d83107e0d82
+ break
}
v.reset(OpAMD64LEAQ)
v.AuxInt = addOff(off1, off2)
v.AddArg(x)
return true
}
- goto end2e2249051d6776a92bcb0d83107e0d82
-end2e2249051d6776a92bcb0d83107e0d82:
- ;
// match: (LEAQ [off1] {sym1} (LEAQ1 [off2] {sym2} x y))
// cond: canMergeSym(sym1, sym2)
// result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ1 {
- goto end4e2502574680cc8e02dcc07561e96ef9
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end4e2502574680cc8e02dcc07561e96ef9
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end4e2502574680cc8e02dcc07561e96ef9
-end4e2502574680cc8e02dcc07561e96ef9:
- ;
// match: (LEAQ [off1] {sym1} (LEAQ2 [off2] {sym2} x y))
// cond: canMergeSym(sym1, sym2)
// result: (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ2 {
- goto end92e54b1fbb5ba0b17a6006fe56b4d57b
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end92e54b1fbb5ba0b17a6006fe56b4d57b
+ break
}
v.reset(OpAMD64LEAQ2)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end92e54b1fbb5ba0b17a6006fe56b4d57b
-end92e54b1fbb5ba0b17a6006fe56b4d57b:
- ;
// match: (LEAQ [off1] {sym1} (LEAQ4 [off2] {sym2} x y))
// cond: canMergeSym(sym1, sym2)
// result: (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end5da4c89d542d34d0d7f8848c3ea0fead
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end5da4c89d542d34d0d7f8848c3ea0fead
+ break
}
v.reset(OpAMD64LEAQ4)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end5da4c89d542d34d0d7f8848c3ea0fead
-end5da4c89d542d34d0d7f8848c3ea0fead:
- ;
// match: (LEAQ [off1] {sym1} (LEAQ8 [off2] {sym2} x y))
// cond: canMergeSym(sym1, sym2)
// result: (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto endc051937df5f12598e76c0923b5a60a39
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto endc051937df5f12598e76c0923b5a60a39
+ break
}
v.reset(OpAMD64LEAQ8)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto endc051937df5f12598e76c0923b5a60a39
-endc051937df5f12598e76c0923b5a60a39:
- ;
return false
}
func rewriteValueAMD64_OpAMD64LEAQ1(v *Value, config *Config) bool {
// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
// cond: x.Op != OpSB
// result: (LEAQ1 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endcee67e6c005f58a521fc4f33a98b11c6
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
y := v.Args[1]
if !(x.Op != OpSB) {
- goto endcee67e6c005f58a521fc4f33a98b11c6
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = c + d
v.AddArg(y)
return true
}
- goto endcee67e6c005f58a521fc4f33a98b11c6
-endcee67e6c005f58a521fc4f33a98b11c6:
- ;
// match: (LEAQ1 [c] {s} x (ADDQconst [d] y))
// cond: y.Op != OpSB
// result: (LEAQ1 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end8ae759893af2b32c6dbcdeeca12ca207
+ break
}
d := v.Args[1].AuxInt
y := v.Args[1].Args[0]
if !(y.Op != OpSB) {
- goto end8ae759893af2b32c6dbcdeeca12ca207
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = c + d
v.AddArg(y)
return true
}
- goto end8ae759893af2b32c6dbcdeeca12ca207
-end8ae759893af2b32c6dbcdeeca12ca207:
- ;
// match: (LEAQ1 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
// cond: canMergeSym(sym1, sym2) && x.Op != OpSB
// result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end3b837b0ce1bd6a79804a28ee529fc65b
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[1]
if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
- goto end3b837b0ce1bd6a79804a28ee529fc65b
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end3b837b0ce1bd6a79804a28ee529fc65b
-end3b837b0ce1bd6a79804a28ee529fc65b:
- ;
// match: (LEAQ1 [off1] {sym1} x (LEAQ [off2] {sym2} y))
// cond: canMergeSym(sym1, sym2) && y.Op != OpSB
// result: (LEAQ1 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
x := v.Args[0]
if v.Args[1].Op != OpAMD64LEAQ {
- goto endfd9dd9448d726fc7d82274b404cddb67
+ break
}
off2 := v.Args[1].AuxInt
sym2 := v.Args[1].Aux
y := v.Args[1].Args[0]
if !(canMergeSym(sym1, sym2) && y.Op != OpSB) {
- goto endfd9dd9448d726fc7d82274b404cddb67
+ break
}
v.reset(OpAMD64LEAQ1)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto endfd9dd9448d726fc7d82274b404cddb67
-endfd9dd9448d726fc7d82274b404cddb67:
- ;
return false
}
func rewriteValueAMD64_OpAMD64LEAQ2(v *Value, config *Config) bool {
// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
// cond: x.Op != OpSB
// result: (LEAQ2 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end32327450a43437ef98ffba85d4f64808
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
y := v.Args[1]
if !(x.Op != OpSB) {
- goto end32327450a43437ef98ffba85d4f64808
+ break
}
v.reset(OpAMD64LEAQ2)
v.AuxInt = c + d
v.AddArg(y)
return true
}
- goto end32327450a43437ef98ffba85d4f64808
-end32327450a43437ef98ffba85d4f64808:
- ;
// match: (LEAQ2 [c] {s} x (ADDQconst [d] y))
// cond: y.Op != OpSB
// result: (LEAQ2 [c+2*d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end86e05a0977fd26c884c75b29625c6236
+ break
}
d := v.Args[1].AuxInt
y := v.Args[1].Args[0]
if !(y.Op != OpSB) {
- goto end86e05a0977fd26c884c75b29625c6236
+ break
}
v.reset(OpAMD64LEAQ2)
v.AuxInt = c + 2*d
v.AddArg(y)
return true
}
- goto end86e05a0977fd26c884c75b29625c6236
-end86e05a0977fd26c884c75b29625c6236:
- ;
// match: (LEAQ2 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
// cond: canMergeSym(sym1, sym2) && x.Op != OpSB
// result: (LEAQ2 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end2bf3cb6e212c3f62ab83ce10059e672e
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[1]
if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
- goto end2bf3cb6e212c3f62ab83ce10059e672e
+ break
}
v.reset(OpAMD64LEAQ2)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end2bf3cb6e212c3f62ab83ce10059e672e
-end2bf3cb6e212c3f62ab83ce10059e672e:
- ;
return false
}
func rewriteValueAMD64_OpAMD64LEAQ4(v *Value, config *Config) bool {
// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
// cond: x.Op != OpSB
// result: (LEAQ4 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end2225ec635a27f55cd2e4ddaf3bebdf5b
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
y := v.Args[1]
if !(x.Op != OpSB) {
- goto end2225ec635a27f55cd2e4ddaf3bebdf5b
+ break
}
v.reset(OpAMD64LEAQ4)
v.AuxInt = c + d
v.AddArg(y)
return true
}
- goto end2225ec635a27f55cd2e4ddaf3bebdf5b
-end2225ec635a27f55cd2e4ddaf3bebdf5b:
- ;
// match: (LEAQ4 [c] {s} x (ADDQconst [d] y))
// cond: y.Op != OpSB
// result: (LEAQ4 [c+4*d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endd198c6d7b0038f43476fe50d886ed76b
+ break
}
d := v.Args[1].AuxInt
y := v.Args[1].Args[0]
if !(y.Op != OpSB) {
- goto endd198c6d7b0038f43476fe50d886ed76b
+ break
}
v.reset(OpAMD64LEAQ4)
v.AuxInt = c + 4*d
v.AddArg(y)
return true
}
- goto endd198c6d7b0038f43476fe50d886ed76b
-endd198c6d7b0038f43476fe50d886ed76b:
- ;
// match: (LEAQ4 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
// cond: canMergeSym(sym1, sym2) && x.Op != OpSB
// result: (LEAQ4 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end066907f169f09e56139e801397316c95
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[1]
if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
- goto end066907f169f09e56139e801397316c95
+ break
}
v.reset(OpAMD64LEAQ4)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end066907f169f09e56139e801397316c95
-end066907f169f09e56139e801397316c95:
- ;
return false
}
func rewriteValueAMD64_OpAMD64LEAQ8(v *Value, config *Config) bool {
// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
// cond: x.Op != OpSB
// result: (LEAQ8 [c+d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end26e798ad0167e205b8c670f19cef8122
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
y := v.Args[1]
if !(x.Op != OpSB) {
- goto end26e798ad0167e205b8c670f19cef8122
+ break
}
v.reset(OpAMD64LEAQ8)
v.AuxInt = c + d
v.AddArg(y)
return true
}
- goto end26e798ad0167e205b8c670f19cef8122
-end26e798ad0167e205b8c670f19cef8122:
- ;
// match: (LEAQ8 [c] {s} x (ADDQconst [d] y))
// cond: y.Op != OpSB
// result: (LEAQ8 [c+8*d] {s} x y)
- {
+ for {
c := v.AuxInt
s := v.Aux
x := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end85f87ffff7b951c1d085198e3bee2f09
+ break
}
d := v.Args[1].AuxInt
y := v.Args[1].Args[0]
if !(y.Op != OpSB) {
- goto end85f87ffff7b951c1d085198e3bee2f09
+ break
}
v.reset(OpAMD64LEAQ8)
v.AuxInt = c + 8*d
v.AddArg(y)
return true
}
- goto end85f87ffff7b951c1d085198e3bee2f09
-end85f87ffff7b951c1d085198e3bee2f09:
- ;
// match: (LEAQ8 [off1] {sym1} (LEAQ [off2] {sym2} x) y)
// cond: canMergeSym(sym1, sym2) && x.Op != OpSB
// result: (LEAQ8 [addOff(off1,off2)] {mergeSym(sym1,sym2)} x y)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end6bde9448027690b01bbf30dee061ce23
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
x := v.Args[0].Args[0]
y := v.Args[1]
if !(canMergeSym(sym1, sym2) && x.Op != OpSB) {
- goto end6bde9448027690b01bbf30dee061ce23
+ break
}
v.reset(OpAMD64LEAQ8)
v.AuxInt = addOff(off1, off2)
v.AddArg(y)
return true
}
- goto end6bde9448027690b01bbf30dee061ce23
-end6bde9448027690b01bbf30dee061ce23:
- ;
return false
}
func rewriteValueAMD64_OpLeq16(v *Value, config *Config) bool {
// match: (Leq16 x y)
// cond:
// result: (SETLE (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETLE)
v.AddArg(v0)
return true
}
- goto end586c647ca6bb8ec725eea917c743d1ea
-end586c647ca6bb8ec725eea917c743d1ea:
- ;
return false
}
func rewriteValueAMD64_OpLeq16U(v *Value, config *Config) bool {
// match: (Leq16U x y)
// cond:
// result: (SETBE (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETBE)
v.AddArg(v0)
return true
}
- goto end9c24a81bc6a4a92267bd6638362dfbfc
-end9c24a81bc6a4a92267bd6638362dfbfc:
- ;
return false
}
func rewriteValueAMD64_OpLeq32(v *Value, config *Config) bool {
// match: (Leq32 x y)
// cond:
// result: (SETLE (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETLE)
v.AddArg(v0)
return true
}
- goto end595ee99a9fc3460b2748b9129b139f88
-end595ee99a9fc3460b2748b9129b139f88:
- ;
return false
}
func rewriteValueAMD64_OpLeq32F(v *Value, config *Config) bool {
// match: (Leq32F x y)
// cond:
// result: (SETGEF (UCOMISS y x))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGEF)
v.AddArg(v0)
return true
}
- goto endfee4b989a80cc43328b24f7017e80a17
-endfee4b989a80cc43328b24f7017e80a17:
- ;
return false
}
func rewriteValueAMD64_OpLeq32U(v *Value, config *Config) bool {
// match: (Leq32U x y)
// cond:
// result: (SETBE (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETBE)
v.AddArg(v0)
return true
}
- goto end1a59850aad6cb17c295d0dc359013420
-end1a59850aad6cb17c295d0dc359013420:
- ;
return false
}
func rewriteValueAMD64_OpLeq64(v *Value, config *Config) bool {
// match: (Leq64 x y)
// cond:
// result: (SETLE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETLE)
v.AddArg(v0)
return true
}
- goto end406def83fcbf29cd8fa306170b512de2
-end406def83fcbf29cd8fa306170b512de2:
- ;
return false
}
func rewriteValueAMD64_OpLeq64F(v *Value, config *Config) bool {
// match: (Leq64F x y)
// cond:
// result: (SETGEF (UCOMISD y x))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGEF)
v.AddArg(v0)
return true
}
- goto end6e3de6d4b5668f673e3822d5947edbd0
-end6e3de6d4b5668f673e3822d5947edbd0:
- ;
return false
}
func rewriteValueAMD64_OpLeq64U(v *Value, config *Config) bool {
// match: (Leq64U x y)
// cond:
// result: (SETBE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETBE)
v.AddArg(v0)
return true
}
- goto end52f23c145b80639c8d60420ad4057bc7
-end52f23c145b80639c8d60420ad4057bc7:
- ;
return false
}
func rewriteValueAMD64_OpLeq8(v *Value, config *Config) bool {
// match: (Leq8 x y)
// cond:
// result: (SETLE (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETLE)
v.AddArg(v0)
return true
}
- goto end72ecba6f2a7062cb266923dfec811f79
-end72ecba6f2a7062cb266923dfec811f79:
- ;
return false
}
func rewriteValueAMD64_OpLeq8U(v *Value, config *Config) bool {
// match: (Leq8U x y)
// cond:
// result: (SETBE (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETBE)
v.AddArg(v0)
return true
}
- goto endb043b338cced4f15400d8d6e584ebea7
-endb043b338cced4f15400d8d6e584ebea7:
- ;
return false
}
func rewriteValueAMD64_OpLess16(v *Value, config *Config) bool {
// match: (Less16 x y)
// cond:
// result: (SETL (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETL)
v.AddArg(v0)
return true
}
- goto end2f6c6ba80eda8d68e77a58cba13d3f16
-end2f6c6ba80eda8d68e77a58cba13d3f16:
- ;
return false
}
func rewriteValueAMD64_OpLess16U(v *Value, config *Config) bool {
// match: (Less16U x y)
// cond:
// result: (SETB (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETB)
v.AddArg(v0)
return true
}
- goto end9f65eefe7b83a3c436b5c16664c93703
-end9f65eefe7b83a3c436b5c16664c93703:
- ;
return false
}
func rewriteValueAMD64_OpLess32(v *Value, config *Config) bool {
// match: (Less32 x y)
// cond:
// result: (SETL (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETL)
v.AddArg(v0)
return true
}
- goto end6632ff4ee994eb5b14cdf60c99ac3798
-end6632ff4ee994eb5b14cdf60c99ac3798:
- ;
return false
}
func rewriteValueAMD64_OpLess32F(v *Value, config *Config) bool {
// match: (Less32F x y)
// cond:
// result: (SETGF (UCOMISS y x))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGF)
v.AddArg(v0)
return true
}
- goto end5b3b0c96a7fc2ede81bc89c9abaac9d0
-end5b3b0c96a7fc2ede81bc89c9abaac9d0:
- ;
return false
}
func rewriteValueAMD64_OpLess32U(v *Value, config *Config) bool {
// match: (Less32U x y)
// cond:
// result: (SETB (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETB)
v.AddArg(v0)
return true
}
- goto end39e5a513c7fb0a42817a6cf9c6143b60
-end39e5a513c7fb0a42817a6cf9c6143b60:
- ;
return false
}
func rewriteValueAMD64_OpLess64(v *Value, config *Config) bool {
// match: (Less64 x y)
// cond:
// result: (SETL (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETL)
v.AddArg(v0)
return true
}
- goto enddce827d3e922e8487b61a88c2b1510f2
-enddce827d3e922e8487b61a88c2b1510f2:
- ;
return false
}
func rewriteValueAMD64_OpLess64F(v *Value, config *Config) bool {
// match: (Less64F x y)
// cond:
// result: (SETGF (UCOMISD y x))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETGF)
v.AddArg(v0)
return true
}
- goto endf2be3d2dcb6543d2159e7fff5ccbbb55
-endf2be3d2dcb6543d2159e7fff5ccbbb55:
- ;
return false
}
func rewriteValueAMD64_OpLess64U(v *Value, config *Config) bool {
// match: (Less64U x y)
// cond:
// result: (SETB (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETB)
v.AddArg(v0)
return true
}
- goto endb76d7768f175a44baf6d63d12ab6e81d
-endb76d7768f175a44baf6d63d12ab6e81d:
- ;
return false
}
func rewriteValueAMD64_OpLess8(v *Value, config *Config) bool {
// match: (Less8 x y)
// cond:
// result: (SETL (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETL)
v.AddArg(v0)
return true
}
- goto end314fbffe99f3bd4b07857a80c0b914cd
-end314fbffe99f3bd4b07857a80c0b914cd:
- ;
return false
}
func rewriteValueAMD64_OpLess8U(v *Value, config *Config) bool {
// match: (Less8U x y)
// cond:
// result: (SETB (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETB)
v.AddArg(v0)
return true
}
- goto endadccc5d80fd053a33004ed0759f64d93
-endadccc5d80fd053a33004ed0759f64d93:
- ;
return false
}
func rewriteValueAMD64_OpLoad(v *Value, config *Config) bool {
// match: (Load <t> ptr mem)
// cond: (is64BitInt(t) || isPtr(t))
// result: (MOVQload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(is64BitInt(t) || isPtr(t)) {
- goto end7c4c53acf57ebc5f03273652ba1d5934
+ break
}
v.reset(OpAMD64MOVQload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto end7c4c53acf57ebc5f03273652ba1d5934
-end7c4c53acf57ebc5f03273652ba1d5934:
- ;
// match: (Load <t> ptr mem)
// cond: is32BitInt(t)
// result: (MOVLload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(is32BitInt(t)) {
- goto ende1cfcb15bfbcfd448ce303d0882a4057
+ break
}
v.reset(OpAMD64MOVLload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto ende1cfcb15bfbcfd448ce303d0882a4057
-ende1cfcb15bfbcfd448ce303d0882a4057:
- ;
// match: (Load <t> ptr mem)
// cond: is16BitInt(t)
// result: (MOVWload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(is16BitInt(t)) {
- goto end2d0a1304501ed9f4e9e2d288505a9c7c
+ break
}
v.reset(OpAMD64MOVWload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto end2d0a1304501ed9f4e9e2d288505a9c7c
-end2d0a1304501ed9f4e9e2d288505a9c7c:
- ;
// match: (Load <t> ptr mem)
// cond: (t.IsBoolean() || is8BitInt(t))
// result: (MOVBload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsBoolean() || is8BitInt(t)) {
- goto end8f83bf72293670e75b22d6627bd13f0b
+ break
}
v.reset(OpAMD64MOVBload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto end8f83bf72293670e75b22d6627bd13f0b
-end8f83bf72293670e75b22d6627bd13f0b:
- ;
// match: (Load <t> ptr mem)
// cond: is32BitFloat(t)
// result: (MOVSSload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(is32BitFloat(t)) {
- goto end63383c4895805881aabceebea3c4c533
+ break
}
v.reset(OpAMD64MOVSSload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto end63383c4895805881aabceebea3c4c533
-end63383c4895805881aabceebea3c4c533:
- ;
// match: (Load <t> ptr mem)
// cond: is64BitFloat(t)
// result: (MOVSDload ptr mem)
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(is64BitFloat(t)) {
- goto end99d0858c0a5bb72f0fe4decc748da812
+ break
}
v.reset(OpAMD64MOVSDload)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto end99d0858c0a5bb72f0fe4decc748da812
-end99d0858c0a5bb72f0fe4decc748da812:
- ;
return false
}
func rewriteValueAMD64_OpLrot16(v *Value, config *Config) bool {
// match: (Lrot16 <t> x [c])
// cond:
// result: (ROLWconst <t> [c&15] x)
- {
+ for {
t := v.Type
x := v.Args[0]
c := v.AuxInt
v.AddArg(x)
return true
}
- goto endb23dfa24c619d0068f925899d53ee7fd
-endb23dfa24c619d0068f925899d53ee7fd:
- ;
return false
}
func rewriteValueAMD64_OpLrot32(v *Value, config *Config) bool {
// match: (Lrot32 <t> x [c])
// cond:
// result: (ROLLconst <t> [c&31] x)
- {
+ for {
t := v.Type
x := v.Args[0]
c := v.AuxInt
v.AddArg(x)
return true
}
- goto end38b2215c011896c36845f72ecb72b1b0
-end38b2215c011896c36845f72ecb72b1b0:
- ;
return false
}
func rewriteValueAMD64_OpLrot64(v *Value, config *Config) bool {
// match: (Lrot64 <t> x [c])
// cond:
// result: (ROLQconst <t> [c&63] x)
- {
+ for {
t := v.Type
x := v.Args[0]
c := v.AuxInt
v.AddArg(x)
return true
}
- goto end5cb355e4f3ca387f252ef4f6a55f9f68
-end5cb355e4f3ca387f252ef4f6a55f9f68:
- ;
return false
}
func rewriteValueAMD64_OpLrot8(v *Value, config *Config) bool {
// match: (Lrot8 <t> x [c])
// cond:
// result: (ROLBconst <t> [c&7] x)
- {
+ for {
t := v.Type
x := v.Args[0]
c := v.AuxInt
v.AddArg(x)
return true
}
- goto end26bfb3dd5b537cf13ac9f2978d94ed71
-end26bfb3dd5b537cf13ac9f2978d94ed71:
- ;
return false
}
func rewriteValueAMD64_OpLsh16x16(v *Value, config *Config) bool {
// match: (Lsh16x16 <t> x y)
// cond:
// result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto ende1a6e1781dd669bd74d66fc34c97218f
-ende1a6e1781dd669bd74d66fc34c97218f:
- ;
return false
}
func rewriteValueAMD64_OpLsh16x32(v *Value, config *Config) bool {
// match: (Lsh16x32 <t> x y)
// cond:
// result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end711e661a5b6682f98e7993c2dfa72f45
-end711e661a5b6682f98e7993c2dfa72f45:
- ;
return false
}
func rewriteValueAMD64_OpLsh16x64(v *Value, config *Config) bool {
// match: (Lsh16x64 <t> x y)
// cond:
// result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end4800d2b7d4f0e5acafcdf4e765941570
-end4800d2b7d4f0e5acafcdf4e765941570:
- ;
return false
}
func rewriteValueAMD64_OpLsh16x8(v *Value, config *Config) bool {
// match: (Lsh16x8 <t> x y)
// cond:
// result: (ANDW (SHLW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endbe15f4a70f6c490f30f12a5db0f24ec4
-endbe15f4a70f6c490f30f12a5db0f24ec4:
- ;
return false
}
func rewriteValueAMD64_OpLsh32x16(v *Value, config *Config) bool {
// match: (Lsh32x16 <t> x y)
// cond:
// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end6e9dfb6e850fc86393b2f6b1d509287f
-end6e9dfb6e850fc86393b2f6b1d509287f:
- ;
return false
}
func rewriteValueAMD64_OpLsh32x32(v *Value, config *Config) bool {
// match: (Lsh32x32 <t> x y)
// cond:
// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end9a4d057653a8fdad133aaf4a6b4f2b74
-end9a4d057653a8fdad133aaf4a6b4f2b74:
- ;
return false
}
func rewriteValueAMD64_OpLsh32x64(v *Value, config *Config) bool {
// match: (Lsh32x64 <t> x y)
// cond:
// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endae1486be93eb21ebac539419b5a109cb
-endae1486be93eb21ebac539419b5a109cb:
- ;
return false
}
func rewriteValueAMD64_OpLsh32x8(v *Value, config *Config) bool {
// match: (Lsh32x8 <t> x y)
// cond:
// result: (ANDL (SHLL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endede3d7bbbb6e7ac26b598b75409703f5
-endede3d7bbbb6e7ac26b598b75409703f5:
- ;
return false
}
func rewriteValueAMD64_OpLsh64x16(v *Value, config *Config) bool {
// match: (Lsh64x16 <t> x y)
// cond:
// result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end4dc49d47e1079e618e480ee95c20df6d
-end4dc49d47e1079e618e480ee95c20df6d:
- ;
return false
}
func rewriteValueAMD64_OpLsh64x32(v *Value, config *Config) bool {
// match: (Lsh64x32 <t> x y)
// cond:
// result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end52a5e8c44a38fe265cf0619081d1723b
-end52a5e8c44a38fe265cf0619081d1723b:
- ;
return false
}
func rewriteValueAMD64_OpLsh64x64(v *Value, config *Config) bool {
// match: (Lsh64x64 <t> x y)
// cond:
// result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto enda2931f1f1a64c3e0251febeb894666b0
-enda2931f1f1a64c3e0251febeb894666b0:
- ;
return false
}
func rewriteValueAMD64_OpLsh64x8(v *Value, config *Config) bool {
// match: (Lsh64x8 <t> x y)
// cond:
// result: (ANDQ (SHLQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end8535fcd7c1fc28bbc53844b29ffbdb22
-end8535fcd7c1fc28bbc53844b29ffbdb22:
- ;
return false
}
func rewriteValueAMD64_OpLsh8x16(v *Value, config *Config) bool {
// match: (Lsh8x16 <t> x y)
// cond:
// result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endc4b0328ed4d6943ac1af3662b93ad8e2
-endc4b0328ed4d6943ac1af3662b93ad8e2:
- ;
return false
}
func rewriteValueAMD64_OpLsh8x32(v *Value, config *Config) bool {
// match: (Lsh8x32 <t> x y)
// cond:
// result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end1e6cfcdb7439ccc73f4f59874f3559b2
-end1e6cfcdb7439ccc73f4f59874f3559b2:
- ;
return false
}
func rewriteValueAMD64_OpLsh8x64(v *Value, config *Config) bool {
// match: (Lsh8x64 <t> x y)
// cond:
// result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endf3ea2e740c7fd7ea2caa24357b0bf798
-endf3ea2e740c7fd7ea2caa24357b0bf798:
- ;
return false
}
func rewriteValueAMD64_OpLsh8x8(v *Value, config *Config) bool {
// match: (Lsh8x8 <t> x y)
// cond:
// result: (ANDB (SHLB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end5d557e41670b7ac83d122eeb4029363d
-end5d557e41670b7ac83d122eeb4029363d:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value, config *Config) bool {
// match: (MOVBQSX (MOVBload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVBQSXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBload {
- goto end19c38f3a1a37dca50637c917fa26e4f7
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto end19c38f3a1a37dca50637c917fa26e4f7
-end19c38f3a1a37dca50637c917fa26e4f7:
- ;
// match: (MOVBQSX (ANDBconst [c] x))
// cond: c & 0x80 == 0
// result: (ANDQconst [c & 0x7f] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDBconst {
- goto endf998318725c3cc6c701ebb69a2473650
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if !(c&0x80 == 0) {
- goto endf998318725c3cc6c701ebb69a2473650
+ break
}
v.reset(OpAMD64ANDQconst)
v.AuxInt = c & 0x7f
v.AddArg(x)
return true
}
- goto endf998318725c3cc6c701ebb69a2473650
-endf998318725c3cc6c701ebb69a2473650:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value, config *Config) bool {
// match: (MOVBQZX (MOVBload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVBQZXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBload {
- goto end1169bcf3d56fa24321b002eaebd5a62d
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto end1169bcf3d56fa24321b002eaebd5a62d
-end1169bcf3d56fa24321b002eaebd5a62d:
- ;
// match: (MOVBQZX (ANDBconst [c] x))
// cond:
// result: (ANDQconst [c & 0xff] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDBconst {
- goto enddca0c0e20f19210fe65677bfd758b24e
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto enddca0c0e20f19210fe65677bfd758b24e
-enddca0c0e20f19210fe65677bfd758b24e:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBload(v *Value, config *Config) bool {
// match: (MOVBload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVBload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end7ec9147ab863c1bd59190fed81f894b6
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end7ec9147ab863c1bd59190fed81f894b6
-end7ec9147ab863c1bd59190fed81f894b6:
- ;
// match: (MOVBload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVBload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end3771a59cf66b0df99120d76f4c358fab
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end3771a59cf66b0df99120d76f4c358fab
+ break
}
v.reset(OpAMD64MOVBload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end3771a59cf66b0df99120d76f4c358fab
-end3771a59cf66b0df99120d76f4c358fab:
- ;
// match: (MOVBload [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVBloadidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ1 {
- goto endb5e38220bc6108fb683f1f1e46853bd9
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto endb5e38220bc6108fb683f1f1e46853bd9
+ break
}
v.reset(OpAMD64MOVBloadidx1)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endb5e38220bc6108fb683f1f1e46853bd9
-endb5e38220bc6108fb683f1f1e46853bd9:
- ;
// match: (MOVBload [off] {sym} (ADDQ ptr idx) mem)
// cond: ptr.Op != OpSB
// result: (MOVBloadidx1 [off] {sym} ptr idx mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQ {
- goto end2abf84efc0e06ed9cda71fb8a1ffaacd
+ break
}
ptr := v.Args[0].Args[0]
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(ptr.Op != OpSB) {
- goto end2abf84efc0e06ed9cda71fb8a1ffaacd
+ break
}
v.reset(OpAMD64MOVBloadidx1)
v.AuxInt = off
v.AddArg(mem)
return true
}
- goto end2abf84efc0e06ed9cda71fb8a1ffaacd
-end2abf84efc0e06ed9cda71fb8a1ffaacd:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value, config *Config) bool {
// match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end287a4eb26a59b5f23efa2c6df34711f7
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end287a4eb26a59b5f23efa2c6df34711f7
-end287a4eb26a59b5f23efa2c6df34711f7:
- ;
// match: (MOVBloadidx1 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end3d2e4e850c5e8129cd71a8693403b6c1
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end3d2e4e850c5e8129cd71a8693403b6c1
-end3d2e4e850c5e8129cd71a8693403b6c1:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBstore(v *Value, config *Config) bool {
// match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
// cond:
// result: (MOVBstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBQSX {
- goto end5b3f41f0770d566ff1647dea1d4a40e8
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto end5b3f41f0770d566ff1647dea1d4a40e8
-end5b3f41f0770d566ff1647dea1d4a40e8:
- ;
// match: (MOVBstore [off] {sym} ptr (MOVBQZX x) mem)
// cond:
// result: (MOVBstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBQZX {
- goto end3a2e55db7e03920700c4875f6a55de3b
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto end3a2e55db7e03920700c4875f6a55de3b
-end3a2e55db7e03920700c4875f6a55de3b:
- ;
// match: (MOVBstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVBstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto ende6347ac19d0469ee59d2e7f2e18d1070
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto ende6347ac19d0469ee59d2e7f2e18d1070
-ende6347ac19d0469ee59d2e7f2e18d1070:
- ;
// match: (MOVBstore [off] {sym} ptr (MOVBconst [c]) mem)
// cond: validOff(off)
// result: (MOVBstoreconst [makeValAndOff(int64(int8(c)),off)] {sym} ptr mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endfdf24c49923451a076f1868988b8c9d9
+ break
}
c := v.Args[1].AuxInt
mem := v.Args[2]
if !(validOff(off)) {
- goto endfdf24c49923451a076f1868988b8c9d9
+ break
}
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = makeValAndOff(int64(int8(c)), off)
v.AddArg(mem)
return true
}
- goto endfdf24c49923451a076f1868988b8c9d9
-endfdf24c49923451a076f1868988b8c9d9:
- ;
// match: (MOVBstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVBstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto enda7086cf7f6b8cf81972e2c3d4b12f3fc
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto enda7086cf7f6b8cf81972e2c3d4b12f3fc
+ break
}
v.reset(OpAMD64MOVBstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto enda7086cf7f6b8cf81972e2c3d4b12f3fc
-enda7086cf7f6b8cf81972e2c3d4b12f3fc:
- ;
// match: (MOVBstore [off1] {sym1} (LEAQ1 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVBstoreidx1 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ1 {
- goto ende386ced77f1acdae2e8bbc379803b7cf
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto ende386ced77f1acdae2e8bbc379803b7cf
+ break
}
v.reset(OpAMD64MOVBstoreidx1)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto ende386ced77f1acdae2e8bbc379803b7cf
-ende386ced77f1acdae2e8bbc379803b7cf:
- ;
// match: (MOVBstore [off] {sym} (ADDQ ptr idx) val mem)
// cond: ptr.Op != OpSB
// result: (MOVBstoreidx1 [off] {sym} ptr idx val mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQ {
- goto endb43afe2024f68e41f2538876c4bf49cc
+ break
}
ptr := v.Args[0].Args[0]
idx := v.Args[0].Args[1]
val := v.Args[1]
mem := v.Args[2]
if !(ptr.Op != OpSB) {
- goto endb43afe2024f68e41f2538876c4bf49cc
+ break
}
v.reset(OpAMD64MOVBstoreidx1)
v.AuxInt = off
v.AddArg(mem)
return true
}
- goto endb43afe2024f68e41f2538876c4bf49cc
-endb43afe2024f68e41f2538876c4bf49cc:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value, config *Config) bool {
// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
- {
+ for {
sc := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end8d35ca650b7c40bc43984d3f5925a052
+ break
}
off := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(ValAndOff(sc).canAdd(off)) {
- goto end8d35ca650b7c40bc43984d3f5925a052
+ break
}
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto end8d35ca650b7c40bc43984d3f5925a052
-end8d35ca650b7c40bc43984d3f5925a052:
- ;
// match: (MOVBstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
- {
+ for {
sc := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end8deb839acf84818dd8fc827c0338f42c
+ break
}
off := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
- goto end8deb839acf84818dd8fc827c0338f42c
+ break
}
v.reset(OpAMD64MOVBstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto end8deb839acf84818dd8fc827c0338f42c
-end8deb839acf84818dd8fc827c0338f42c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value, config *Config) bool {
// match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end5e07185968f39170e41a237cc6258752
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end5e07185968f39170e41a237cc6258752
-end5e07185968f39170e41a237cc6258752:
- ;
// match: (MOVBstoreidx1 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endf1e4b8d5da2530ca81e2c01dc2892875
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endf1e4b8d5da2530ca81e2c01dc2892875
-endf1e4b8d5da2530ca81e2c01dc2892875:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value, config *Config) bool {
// match: (MOVLQSX (MOVLload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVLQSXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLload {
- goto end9498ad52d5051e8e3ee9b0ed7af68d01
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto end9498ad52d5051e8e3ee9b0ed7af68d01
-end9498ad52d5051e8e3ee9b0ed7af68d01:
- ;
// match: (MOVLQSX (ANDLconst [c] x))
// cond: c & 0x80000000 == 0
// result: (ANDQconst [c & 0x7fffffff] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDLconst {
- goto end286a5aa0d10b04039cbe6e09307b4cbe
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if !(c&0x80000000 == 0) {
- goto end286a5aa0d10b04039cbe6e09307b4cbe
+ break
}
v.reset(OpAMD64ANDQconst)
v.AuxInt = c & 0x7fffffff
v.AddArg(x)
return true
}
- goto end286a5aa0d10b04039cbe6e09307b4cbe
-end286a5aa0d10b04039cbe6e09307b4cbe:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value, config *Config) bool {
// match: (MOVLQZX (MOVLload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVLQZXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLload {
- goto endb00602ccd4180bd749a3b01914264fbc
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto endb00602ccd4180bd749a3b01914264fbc
-endb00602ccd4180bd749a3b01914264fbc:
- ;
// match: (MOVLQZX (ANDLconst [c] x))
// cond:
// result: (ANDQconst [c & 0xffffffff] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDLconst {
- goto end71446f0e4f530fbbc6b25a3d07761c06
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end71446f0e4f530fbbc6b25a3d07761c06
-end71446f0e4f530fbbc6b25a3d07761c06:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLload(v *Value, config *Config) bool {
// match: (MOVLload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVLload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end0c8b8a40360c5c581d92723eca04d340
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end0c8b8a40360c5c581d92723eca04d340
-end0c8b8a40360c5c581d92723eca04d340:
- ;
// match: (MOVLload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto enddb9e59335876d8a565c425731438a1b3
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto enddb9e59335876d8a565c425731438a1b3
+ break
}
v.reset(OpAMD64MOVLload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto enddb9e59335876d8a565c425731438a1b3
-enddb9e59335876d8a565c425731438a1b3:
- ;
// match: (MOVLload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end6eed46982cfbceace4784afdf29ba2b9
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end6eed46982cfbceace4784afdf29ba2b9
+ break
}
v.reset(OpAMD64MOVLloadidx4)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end6eed46982cfbceace4784afdf29ba2b9
-end6eed46982cfbceace4784afdf29ba2b9:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value, config *Config) bool {
// match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endcafad33c3669685fdfee020f111fdcb6
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endcafad33c3669685fdfee020f111fdcb6
-endcafad33c3669685fdfee020f111fdcb6:
- ;
// match: (MOVLloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVLloadidx4 [c+4*d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endfb8f54bfe07226dcb7d4e2d6df319707
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endfb8f54bfe07226dcb7d4e2d6df319707
-endfb8f54bfe07226dcb7d4e2d6df319707:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLstore(v *Value, config *Config) bool {
// match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
// cond:
// result: (MOVLstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLQSX {
- goto end1fb7b2ae707c76d30927c21f85d77472
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto end1fb7b2ae707c76d30927c21f85d77472
-end1fb7b2ae707c76d30927c21f85d77472:
- ;
// match: (MOVLstore [off] {sym} ptr (MOVLQZX x) mem)
// cond:
// result: (MOVLstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLQZX {
- goto end199e8c23a5e7e99728a43d6a83b2c2cf
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto end199e8c23a5e7e99728a43d6a83b2c2cf
-end199e8c23a5e7e99728a43d6a83b2c2cf:
- ;
// match: (MOVLstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVLstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end43bffdb8d9c1fc85a95778d4911955f1
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end43bffdb8d9c1fc85a95778d4911955f1
-end43bffdb8d9c1fc85a95778d4911955f1:
- ;
// match: (MOVLstore [off] {sym} ptr (MOVLconst [c]) mem)
// cond: validOff(off)
// result: (MOVLstoreconst [makeValAndOff(int64(int32(c)),off)] {sym} ptr mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto enda62a54c45bf42db801af4095d27faccd
+ break
}
c := v.Args[1].AuxInt
mem := v.Args[2]
if !(validOff(off)) {
- goto enda62a54c45bf42db801af4095d27faccd
+ break
}
v.reset(OpAMD64MOVLstoreconst)
v.AuxInt = makeValAndOff(int64(int32(c)), off)
v.AddArg(mem)
return true
}
- goto enda62a54c45bf42db801af4095d27faccd
-enda62a54c45bf42db801af4095d27faccd:
- ;
// match: (MOVLstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endd57b1e4313fc7a3331340a9af00ba116
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto endd57b1e4313fc7a3331340a9af00ba116
+ break
}
v.reset(OpAMD64MOVLstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endd57b1e4313fc7a3331340a9af00ba116
-endd57b1e4313fc7a3331340a9af00ba116:
- ;
// match: (MOVLstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end6d2bbe089d6de8d261fcdeef263d2f7c
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end6d2bbe089d6de8d261fcdeef263d2f7c
+ break
}
v.reset(OpAMD64MOVLstoreidx4)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end6d2bbe089d6de8d261fcdeef263d2f7c
-end6d2bbe089d6de8d261fcdeef263d2f7c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value, config *Config) bool {
// match: (MOVLstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
- {
+ for {
sc := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end4981598152dd0763f1d735810a7d34e8
+ break
}
off := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(ValAndOff(sc).canAdd(off)) {
- goto end4981598152dd0763f1d735810a7d34e8
+ break
}
v.reset(OpAMD64MOVLstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto end4981598152dd0763f1d735810a7d34e8
-end4981598152dd0763f1d735810a7d34e8:
- ;
// match: (MOVLstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
// result: (MOVLstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
- {
+ for {
sc := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endd579250954b5df84a77518b36f739e12
+ break
}
off := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
- goto endd579250954b5df84a77518b36f739e12
+ break
}
v.reset(OpAMD64MOVLstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto endd579250954b5df84a77518b36f739e12
-endd579250954b5df84a77518b36f739e12:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value, config *Config) bool {
// match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endd72a73ada3e68139d21049bd337bcfd2
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endd72a73ada3e68139d21049bd337bcfd2
-endd72a73ada3e68139d21049bd337bcfd2:
- ;
// match: (MOVLstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVLstoreidx4 [c+4*d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endea783679ed46542bc48309b9fd2f6054
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endea783679ed46542bc48309b9fd2f6054
-endea783679ed46542bc48309b9fd2f6054:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVOload(v *Value, config *Config) bool {
// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVOload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endf1e8fcf569ddd8b3f7a2f61696971913
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endf1e8fcf569ddd8b3f7a2f61696971913
-endf1e8fcf569ddd8b3f7a2f61696971913:
- ;
// match: (MOVOload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVOload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endd36cf9b00af7a8f44fb8c60067a8efb2
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto endd36cf9b00af7a8f44fb8c60067a8efb2
+ break
}
v.reset(OpAMD64MOVOload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endd36cf9b00af7a8f44fb8c60067a8efb2
-endd36cf9b00af7a8f44fb8c60067a8efb2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVOstore(v *Value, config *Config) bool {
// match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVOstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end2be573aa1bd919e567e6156a4ee36517
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end2be573aa1bd919e567e6156a4ee36517
-end2be573aa1bd919e567e6156a4ee36517:
- ;
// match: (MOVOstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVOstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endc28b9b3efe9eb235e1586c4555280c20
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto endc28b9b3efe9eb235e1586c4555280c20
+ break
}
v.reset(OpAMD64MOVOstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endc28b9b3efe9eb235e1586c4555280c20
-endc28b9b3efe9eb235e1586c4555280c20:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVQload(v *Value, config *Config) bool {
// match: (MOVQload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVQload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end0b8c50dd7faefb7d046f9a27e054df77
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end0b8c50dd7faefb7d046f9a27e054df77
-end0b8c50dd7faefb7d046f9a27e054df77:
- ;
// match: (MOVQload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVQload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endd0c093adc4f05f2037005734c77d3cc4
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto endd0c093adc4f05f2037005734c77d3cc4
+ break
}
v.reset(OpAMD64MOVQload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endd0c093adc4f05f2037005734c77d3cc4
-endd0c093adc4f05f2037005734c77d3cc4:
- ;
// match: (MOVQload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVQloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto end74a50d810fb3945e809f608cd094a59c
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end74a50d810fb3945e809f608cd094a59c
+ break
}
v.reset(OpAMD64MOVQloadidx8)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end74a50d810fb3945e809f608cd094a59c
-end74a50d810fb3945e809f608cd094a59c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value, config *Config) bool {
// match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVQloadidx8 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end012c0c0292dbfd55f520e4d88d9247e4
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end012c0c0292dbfd55f520e4d88d9247e4
-end012c0c0292dbfd55f520e4d88d9247e4:
- ;
// match: (MOVQloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVQloadidx8 [c+8*d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endd36e82450f4737c06501b7bc9e881d13
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endd36e82450f4737c06501b7bc9e881d13
-endd36e82450f4737c06501b7bc9e881d13:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVQstore(v *Value, config *Config) bool {
// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVQstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end0a110b5e42a4576c32fda50590092848
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end0a110b5e42a4576c32fda50590092848
-end0a110b5e42a4576c32fda50590092848:
- ;
// match: (MOVQstore [off] {sym} ptr (MOVQconst [c]) mem)
// cond: validValAndOff(c,off)
// result: (MOVQstoreconst [makeValAndOff(c,off)] {sym} ptr mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto endda0f4b36e19753762dbd1c6ee05e4c81
+ break
}
c := v.Args[1].AuxInt
mem := v.Args[2]
if !(validValAndOff(c, off)) {
- goto endda0f4b36e19753762dbd1c6ee05e4c81
+ break
}
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = makeValAndOff(c, off)
v.AddArg(mem)
return true
}
- goto endda0f4b36e19753762dbd1c6ee05e4c81
-endda0f4b36e19753762dbd1c6ee05e4c81:
- ;
// match: (MOVQstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVQstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end9a0cfe20b3b0f587e252760907c1b5c0
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end9a0cfe20b3b0f587e252760907c1b5c0
+ break
}
v.reset(OpAMD64MOVQstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end9a0cfe20b3b0f587e252760907c1b5c0
-end9a0cfe20b3b0f587e252760907c1b5c0:
- ;
// match: (MOVQstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVQstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto end442c322e6719e280b6be1c12858e49d7
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end442c322e6719e280b6be1c12858e49d7
+ break
}
v.reset(OpAMD64MOVQstoreidx8)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end442c322e6719e280b6be1c12858e49d7
-end442c322e6719e280b6be1c12858e49d7:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value, config *Config) bool {
// match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
- {
+ for {
sc := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end3694207cd20e8e1cc719e179bdfe0c74
+ break
}
off := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(ValAndOff(sc).canAdd(off)) {
- goto end3694207cd20e8e1cc719e179bdfe0c74
+ break
}
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto end3694207cd20e8e1cc719e179bdfe0c74
-end3694207cd20e8e1cc719e179bdfe0c74:
- ;
// match: (MOVQstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
// result: (MOVQstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
- {
+ for {
sc := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endf405b27b22dbf76f83abd1b5ad5e53d9
+ break
}
off := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
- goto endf405b27b22dbf76f83abd1b5ad5e53d9
+ break
}
v.reset(OpAMD64MOVQstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto endf405b27b22dbf76f83abd1b5ad5e53d9
-endf405b27b22dbf76f83abd1b5ad5e53d9:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value, config *Config) bool {
// match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end775cfe4359adc4bffc346289df14bbc3
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end775cfe4359adc4bffc346289df14bbc3
-end775cfe4359adc4bffc346289df14bbc3:
- ;
// match: (MOVQstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVQstoreidx8 [c+8*d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end20281fb6ccf09a9b56abdba46f443232
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end20281fb6ccf09a9b56abdba46f443232
-end20281fb6ccf09a9b56abdba46f443232:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSDload(v *Value, config *Config) bool {
// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVSDload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end6dad9bf78e7368bb095eb2dfba7e244a
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end6dad9bf78e7368bb095eb2dfba7e244a
-end6dad9bf78e7368bb095eb2dfba7e244a:
- ;
// match: (MOVSDload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSDload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end96fa9c439e31050aa91582bc2a9f2c20
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end96fa9c439e31050aa91582bc2a9f2c20
+ break
}
v.reset(OpAMD64MOVSDload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end96fa9c439e31050aa91582bc2a9f2c20
-end96fa9c439e31050aa91582bc2a9f2c20:
- ;
// match: (MOVSDload [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSDloadidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto endbcb2ce441824d0e3a4b501018cfa7f60
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto endbcb2ce441824d0e3a4b501018cfa7f60
+ break
}
v.reset(OpAMD64MOVSDloadidx8)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endbcb2ce441824d0e3a4b501018cfa7f60
-endbcb2ce441824d0e3a4b501018cfa7f60:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value, config *Config) bool {
// match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endb313602cfa64c282cc86c27c7183c507
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endb313602cfa64c282cc86c27c7183c507
-endb313602cfa64c282cc86c27c7183c507:
- ;
// match: (MOVSDloadidx8 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVSDloadidx8 [c+8*d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endfb406e2cba383116291b60825765637c
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endfb406e2cba383116291b60825765637c
-endfb406e2cba383116291b60825765637c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value, config *Config) bool {
// match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVSDstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end6c6160664143cc66e63e67b9aa43a7ef
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end6c6160664143cc66e63e67b9aa43a7ef
-end6c6160664143cc66e63e67b9aa43a7ef:
- ;
// match: (MOVSDstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSDstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end415dde14f3400bec1b2756174a5d7179
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end415dde14f3400bec1b2756174a5d7179
+ break
}
v.reset(OpAMD64MOVSDstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end415dde14f3400bec1b2756174a5d7179
-end415dde14f3400bec1b2756174a5d7179:
- ;
// match: (MOVSDstore [off1] {sym1} (LEAQ8 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSDstoreidx8 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ8 {
- goto end1ad6fc0c5b59610dabf7f9595a48a230
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end1ad6fc0c5b59610dabf7f9595a48a230
+ break
}
v.reset(OpAMD64MOVSDstoreidx8)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end1ad6fc0c5b59610dabf7f9595a48a230
-end1ad6fc0c5b59610dabf7f9595a48a230:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value, config *Config) bool {
// match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end8b8f41236593d5d5e83663cc14350fe8
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end8b8f41236593d5d5e83663cc14350fe8
-end8b8f41236593d5d5e83663cc14350fe8:
- ;
// match: (MOVSDstoreidx8 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVSDstoreidx8 [c+8*d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end94b7159715acb6ebb94b08b3a826f5fe
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end94b7159715acb6ebb94b08b3a826f5fe
-end94b7159715acb6ebb94b08b3a826f5fe:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSSload(v *Value, config *Config) bool {
// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVSSload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end96d63dbb64b0adfa944684c9e939c972
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end96d63dbb64b0adfa944684c9e939c972
-end96d63dbb64b0adfa944684c9e939c972:
- ;
// match: (MOVSSload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSSload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end15f2583bd72ad7fc077b3952634a1c85
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end15f2583bd72ad7fc077b3952634a1c85
+ break
}
v.reset(OpAMD64MOVSSload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end15f2583bd72ad7fc077b3952634a1c85
-end15f2583bd72ad7fc077b3952634a1c85:
- ;
// match: (MOVSSload [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSSloadidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end49722f4a0adba31bb143601ce1d2aae0
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end49722f4a0adba31bb143601ce1d2aae0
+ break
}
v.reset(OpAMD64MOVSSloadidx4)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end49722f4a0adba31bb143601ce1d2aae0
-end49722f4a0adba31bb143601ce1d2aae0:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value, config *Config) bool {
// match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end2317614a112d773b1209327d552bb022
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end2317614a112d773b1209327d552bb022
-end2317614a112d773b1209327d552bb022:
- ;
// match: (MOVSSloadidx4 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVSSloadidx4 [c+4*d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endd3063853eaa3813f3c95eedeba23e391
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endd3063853eaa3813f3c95eedeba23e391
-endd3063853eaa3813f3c95eedeba23e391:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value, config *Config) bool {
// match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVSSstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endf711aa4081a9b2924b55387d4f70cfd6
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endf711aa4081a9b2924b55387d4f70cfd6
-endf711aa4081a9b2924b55387d4f70cfd6:
- ;
// match: (MOVSSstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSSstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end70ebc170131920e515e3f416a6b952c5
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end70ebc170131920e515e3f416a6b952c5
+ break
}
v.reset(OpAMD64MOVSSstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end70ebc170131920e515e3f416a6b952c5
-end70ebc170131920e515e3f416a6b952c5:
- ;
// match: (MOVSSstore [off1] {sym1} (LEAQ4 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVSSstoreidx4 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ4 {
- goto end1622dc435e45833eda4d29d44df7cc34
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end1622dc435e45833eda4d29d44df7cc34
+ break
}
v.reset(OpAMD64MOVSSstoreidx4)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end1622dc435e45833eda4d29d44df7cc34
-end1622dc435e45833eda4d29d44df7cc34:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value, config *Config) bool {
// match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end5995724dec9833993ca0b1c827919b6a
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end5995724dec9833993ca0b1c827919b6a
-end5995724dec9833993ca0b1c827919b6a:
- ;
// match: (MOVSSstoreidx4 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVSSstoreidx4 [c+4*d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto endad50732309bcc958cffc54992194cdd6
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto endad50732309bcc958cffc54992194cdd6
-endad50732309bcc958cffc54992194cdd6:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value, config *Config) bool {
// match: (MOVWQSX (MOVWload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVWQSXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWload {
- goto endef39da125e2794cdafd008426ecc91eb
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto endef39da125e2794cdafd008426ecc91eb
-endef39da125e2794cdafd008426ecc91eb:
- ;
// match: (MOVWQSX (ANDWconst [c] x))
// cond: c & 0x8000 == 0
// result: (ANDQconst [c & 0x7fff] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDWconst {
- goto end8581b4c4dfd1278e97aa536308519e68
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
if !(c&0x8000 == 0) {
- goto end8581b4c4dfd1278e97aa536308519e68
+ break
}
v.reset(OpAMD64ANDQconst)
v.AuxInt = c & 0x7fff
v.AddArg(x)
return true
}
- goto end8581b4c4dfd1278e97aa536308519e68
-end8581b4c4dfd1278e97aa536308519e68:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value, config *Config) bool {
// match: (MOVWQZX (MOVWload [off] {sym} ptr mem))
// cond:
// result: @v.Args[0].Block (MOVWQZXload <v.Type> [off] {sym} ptr mem)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWload {
- goto end348d59b382c9d0c64896811facbe4c5e
+ break
}
off := v.Args[0].AuxInt
sym := v.Args[0].Aux
v0.AddArg(mem)
return true
}
- goto end348d59b382c9d0c64896811facbe4c5e
-end348d59b382c9d0c64896811facbe4c5e:
- ;
// match: (MOVWQZX (ANDWconst [c] x))
// cond:
// result: (ANDQconst [c & 0xffff] x)
- {
+ for {
if v.Args[0].Op != OpAMD64ANDWconst {
- goto end15c2a3b0ade49892e79289e562bac52f
+ break
}
c := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end15c2a3b0ade49892e79289e562bac52f
-end15c2a3b0ade49892e79289e562bac52f:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWload(v *Value, config *Config) bool {
// match: (MOVWload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond:
// result: (MOVWload [addOff(off1, off2)] {sym} ptr mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endfcb0ce76f96e8b0c2eb19a9b827c1b73
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endfcb0ce76f96e8b0c2eb19a9b827c1b73
-endfcb0ce76f96e8b0c2eb19a9b827c1b73:
- ;
// match: (MOVWload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWload [addOff(off1,off2)] {mergeSym(sym1,sym2)} base mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end7a79314cb49bf53d79c38c3077d87457
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
base := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end7a79314cb49bf53d79c38c3077d87457
+ break
}
v.reset(OpAMD64MOVWload)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end7a79314cb49bf53d79c38c3077d87457
-end7a79314cb49bf53d79c38c3077d87457:
- ;
// match: (MOVWload [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWloadidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ2 {
- goto end1a7be5e27e24f56f760b50d4d2f2a8da
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
idx := v.Args[0].Args[1]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2)) {
- goto end1a7be5e27e24f56f760b50d4d2f2a8da
+ break
}
v.reset(OpAMD64MOVWloadidx2)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end1a7be5e27e24f56f760b50d4d2f2a8da
-end1a7be5e27e24f56f760b50d4d2f2a8da:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value, config *Config) bool {
// match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end1a8b9db99bc480ce4f8cc0fa0e6024ea
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end1a8b9db99bc480ce4f8cc0fa0e6024ea
-end1a8b9db99bc480ce4f8cc0fa0e6024ea:
- ;
// match: (MOVWloadidx2 [c] {sym} ptr (ADDQconst [d] idx) mem)
// cond:
// result: (MOVWloadidx2 [c+2*d] {sym} ptr idx mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end38e4b4448cc3c61b0691bc11c61c7098
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end38e4b4448cc3c61b0691bc11c61c7098
-end38e4b4448cc3c61b0691bc11c61c7098:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWstore(v *Value, config *Config) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWQSX {
- goto endca90c534e75c7f5cb803504d119a853f
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto endca90c534e75c7f5cb803504d119a853f
-endca90c534e75c7f5cb803504d119a853f:
- ;
// match: (MOVWstore [off] {sym} ptr (MOVWQZX x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWQZX {
- goto end187fe73dfaf9cf5f4c349283b4dfd9d1
+ break
}
x := v.Args[1].Args[0]
mem := v.Args[2]
v.AddArg(mem)
return true
}
- goto end187fe73dfaf9cf5f4c349283b4dfd9d1
-end187fe73dfaf9cf5f4c349283b4dfd9d1:
- ;
// match: (MOVWstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond:
// result: (MOVWstore [addOff(off1, off2)] {sym} ptr val mem)
- {
+ for {
off1 := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto endda15fdd59aa956ded0440188f38de1aa
+ break
}
off2 := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto endda15fdd59aa956ded0440188f38de1aa
-endda15fdd59aa956ded0440188f38de1aa:
- ;
// match: (MOVWstore [off] {sym} ptr (MOVWconst [c]) mem)
// cond: validOff(off)
// result: (MOVWstoreconst [makeValAndOff(int64(int16(c)),off)] {sym} ptr mem)
- {
+ for {
off := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end60327daf9965d73a8c1971d098e1e31d
+ break
}
c := v.Args[1].AuxInt
mem := v.Args[2]
if !(validOff(off)) {
- goto end60327daf9965d73a8c1971d098e1e31d
+ break
}
v.reset(OpAMD64MOVWstoreconst)
v.AuxInt = makeValAndOff(int64(int16(c)), off)
v.AddArg(mem)
return true
}
- goto end60327daf9965d73a8c1971d098e1e31d
-end60327daf9965d73a8c1971d098e1e31d:
- ;
// match: (MOVWstore [off1] {sym1} (LEAQ [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWstore [addOff(off1,off2)] {mergeSym(sym1,sym2)} base val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto end4cc466ede8e64e415c899ccac81c0f27
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto end4cc466ede8e64e415c899ccac81c0f27
+ break
}
v.reset(OpAMD64MOVWstore)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto end4cc466ede8e64e415c899ccac81c0f27
-end4cc466ede8e64e415c899ccac81c0f27:
- ;
// match: (MOVWstore [off1] {sym1} (LEAQ2 [off2] {sym2} ptr idx) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWstoreidx2 [addOff(off1, off2)] {mergeSym(sym1,sym2)} ptr idx val mem)
- {
+ for {
off1 := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ2 {
- goto endecfc76d1ba8fcce5d4110a452cd39752
+ break
}
off2 := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
val := v.Args[1]
mem := v.Args[2]
if !(canMergeSym(sym1, sym2)) {
- goto endecfc76d1ba8fcce5d4110a452cd39752
+ break
}
v.reset(OpAMD64MOVWstoreidx2)
v.AuxInt = addOff(off1, off2)
v.AddArg(mem)
return true
}
- goto endecfc76d1ba8fcce5d4110a452cd39752
-endecfc76d1ba8fcce5d4110a452cd39752:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value, config *Config) bool {
// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
- {
+ for {
sc := v.AuxInt
s := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end8825edac065f0e1c615ca5e6ba40e2de
+ break
}
off := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(ValAndOff(sc).canAdd(off)) {
- goto end8825edac065f0e1c615ca5e6ba40e2de
+ break
}
v.reset(OpAMD64MOVWstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto end8825edac065f0e1c615ca5e6ba40e2de
-end8825edac065f0e1c615ca5e6ba40e2de:
- ;
// match: (MOVWstoreconst [sc] {sym1} (LEAQ [off] {sym2} ptr) mem)
// cond: canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)
// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {mergeSym(sym1, sym2)} ptr mem)
- {
+ for {
sc := v.AuxInt
sym1 := v.Aux
if v.Args[0].Op != OpAMD64LEAQ {
- goto endba47397e07b40a64fa4cad36ac2e32ad
+ break
}
off := v.Args[0].AuxInt
sym2 := v.Args[0].Aux
ptr := v.Args[0].Args[0]
mem := v.Args[1]
if !(canMergeSym(sym1, sym2) && ValAndOff(sc).canAdd(off)) {
- goto endba47397e07b40a64fa4cad36ac2e32ad
+ break
}
v.reset(OpAMD64MOVWstoreconst)
v.AuxInt = ValAndOff(sc).add(off)
v.AddArg(mem)
return true
}
- goto endba47397e07b40a64fa4cad36ac2e32ad
-endba47397e07b40a64fa4cad36ac2e32ad:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value, config *Config) bool {
// match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVWstoreidx2 [c+d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
if v.Args[0].Op != OpAMD64ADDQconst {
- goto end8e684d397fadfa1c3f0783597ca01cc7
+ break
}
d := v.Args[0].AuxInt
ptr := v.Args[0].Args[0]
v.AddArg(mem)
return true
}
- goto end8e684d397fadfa1c3f0783597ca01cc7
-end8e684d397fadfa1c3f0783597ca01cc7:
- ;
// match: (MOVWstoreidx2 [c] {sym} ptr (ADDQconst [d] idx) val mem)
// cond:
// result: (MOVWstoreidx2 [c+2*d] {sym} ptr idx val mem)
- {
+ for {
c := v.AuxInt
sym := v.Aux
ptr := v.Args[0]
if v.Args[1].Op != OpAMD64ADDQconst {
- goto end9701df480a14263338b1d37a15b59eb5
+ break
}
d := v.Args[1].AuxInt
idx := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end9701df480a14263338b1d37a15b59eb5
-end9701df480a14263338b1d37a15b59eb5:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULB(v *Value, config *Config) bool {
// match: (MULB x (MOVBconst [c]))
// cond:
// result: (MULBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end66c6419213ddeb52b1c53fb589a70e5f
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64MULBconst)
v.AddArg(x)
return true
}
- goto end66c6419213ddeb52b1c53fb589a70e5f
-end66c6419213ddeb52b1c53fb589a70e5f:
- ;
// match: (MULB (MOVBconst [c]) x)
// cond:
// result: (MULBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end7e82c8dbbba265b78035ca7df394bb06
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end7e82c8dbbba265b78035ca7df394bb06
-end7e82c8dbbba265b78035ca7df394bb06:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULBconst(v *Value, config *Config) bool {
// match: (MULBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [c*d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endf2db9f96016085f8cb4082b4af01b2aa
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = c * d
return true
}
- goto endf2db9f96016085f8cb4082b4af01b2aa
-endf2db9f96016085f8cb4082b4af01b2aa:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULL(v *Value, config *Config) bool {
// match: (MULL x (MOVLconst [c]))
// cond:
// result: (MULLconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end893477a261bcad6c2821b77c83075c6c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64MULLconst)
v.AddArg(x)
return true
}
- goto end893477a261bcad6c2821b77c83075c6c
-end893477a261bcad6c2821b77c83075c6c:
- ;
// match: (MULL (MOVLconst [c]) x)
// cond:
// result: (MULLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end8a0f957c528a54eecb0dbfc5d96e017a
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end8a0f957c528a54eecb0dbfc5d96e017a
-end8a0f957c528a54eecb0dbfc5d96e017a:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULLconst(v *Value, config *Config) bool {
// match: (MULLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [c*d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endd5732835ed1276ef8b728bcfc1289f73
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = c * d
return true
}
- goto endd5732835ed1276ef8b728bcfc1289f73
-endd5732835ed1276ef8b728bcfc1289f73:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULQ(v *Value, config *Config) bool {
// match: (MULQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (MULQconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto endb38c6e3e0ddfa25ba0ef9684ac1528c0
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto endb38c6e3e0ddfa25ba0ef9684ac1528c0
+ break
}
v.reset(OpAMD64MULQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto endb38c6e3e0ddfa25ba0ef9684ac1528c0
-endb38c6e3e0ddfa25ba0ef9684ac1528c0:
- ;
// match: (MULQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (MULQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end9cb4f29b0bd7141639416735dcbb3b87
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto end9cb4f29b0bd7141639416735dcbb3b87
+ break
}
v.reset(OpAMD64MULQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end9cb4f29b0bd7141639416735dcbb3b87
-end9cb4f29b0bd7141639416735dcbb3b87:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULQconst(v *Value, config *Config) bool {
// match: (MULQconst [-1] x)
// cond:
// result: (NEGQ x)
- {
+ for {
if v.AuxInt != -1 {
- goto end82501cca6b5fb121a7f8b197e55f2fec
+ break
}
x := v.Args[0]
v.reset(OpAMD64NEGQ)
v.AddArg(x)
return true
}
- goto end82501cca6b5fb121a7f8b197e55f2fec
-end82501cca6b5fb121a7f8b197e55f2fec:
- ;
// match: (MULQconst [0] _)
// cond:
// result: (MOVQconst [0])
- {
+ for {
if v.AuxInt != 0 {
- goto endcb9faa068e3558ff44daaf1d47d091b5
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto endcb9faa068e3558ff44daaf1d47d091b5
-endcb9faa068e3558ff44daaf1d47d091b5:
- ;
// match: (MULQconst [1] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != 1 {
- goto end0b527e71db2b288b2841a1f757aa580d
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end0b527e71db2b288b2841a1f757aa580d
-end0b527e71db2b288b2841a1f757aa580d:
- ;
// match: (MULQconst [3] x)
// cond:
// result: (LEAQ2 x x)
- {
+ for {
if v.AuxInt != 3 {
- goto end34a86f261671b5852bec6c57155fe0da
+ break
}
x := v.Args[0]
v.reset(OpAMD64LEAQ2)
v.AddArg(x)
return true
}
- goto end34a86f261671b5852bec6c57155fe0da
-end34a86f261671b5852bec6c57155fe0da:
- ;
// match: (MULQconst [5] x)
// cond:
// result: (LEAQ4 x x)
- {
+ for {
if v.AuxInt != 5 {
- goto end534601906c45a9171a9fec3e4b82b189
+ break
}
x := v.Args[0]
v.reset(OpAMD64LEAQ4)
v.AddArg(x)
return true
}
- goto end534601906c45a9171a9fec3e4b82b189
-end534601906c45a9171a9fec3e4b82b189:
- ;
// match: (MULQconst [9] x)
// cond:
// result: (LEAQ8 x x)
- {
+ for {
if v.AuxInt != 9 {
- goto end48a2280b6459821289c56073b8354997
+ break
}
x := v.Args[0]
v.reset(OpAMD64LEAQ8)
v.AddArg(x)
return true
}
- goto end48a2280b6459821289c56073b8354997
-end48a2280b6459821289c56073b8354997:
- ;
// match: (MULQconst [c] x)
// cond: isPowerOfTwo(c)
// result: (SHLQconst [log2(c)] x)
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(isPowerOfTwo(c)) {
- goto end75076953dbfe022526a153eda99b39b2
+ break
}
v.reset(OpAMD64SHLQconst)
v.AuxInt = log2(c)
v.AddArg(x)
return true
}
- goto end75076953dbfe022526a153eda99b39b2
-end75076953dbfe022526a153eda99b39b2:
- ;
// match: (MULQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [c*d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end55c38c5c405101e610d7ba7fc702ddc0
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = c * d
return true
}
- goto end55c38c5c405101e610d7ba7fc702ddc0
-end55c38c5c405101e610d7ba7fc702ddc0:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULW(v *Value, config *Config) bool {
// match: (MULW x (MOVWconst [c]))
// cond:
// result: (MULWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end542112cc08217d4bdffc1a645d290ffb
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64MULWconst)
v.AddArg(x)
return true
}
- goto end542112cc08217d4bdffc1a645d290ffb
-end542112cc08217d4bdffc1a645d290ffb:
- ;
// match: (MULW (MOVWconst [c]) x)
// cond:
// result: (MULWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto endd97b4245ced2b3d27d8c555b06281de4
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto endd97b4245ced2b3d27d8c555b06281de4
-endd97b4245ced2b3d27d8c555b06281de4:
- ;
return false
}
func rewriteValueAMD64_OpAMD64MULWconst(v *Value, config *Config) bool {
// match: (MULWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [c*d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end61dbc9d9e93dd6946a20a1f475b3f74b
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = c * d
return true
}
- goto end61dbc9d9e93dd6946a20a1f475b3f74b
-end61dbc9d9e93dd6946a20a1f475b3f74b:
- ;
return false
}
func rewriteValueAMD64_OpMod16(v *Value, config *Config) bool {
// match: (Mod16 x y)
// cond:
// result: (MODW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODW)
v.AddArg(y)
return true
}
- goto end036bac694be9fe0d6b00b86c2e625990
-end036bac694be9fe0d6b00b86c2e625990:
- ;
return false
}
func rewriteValueAMD64_OpMod16u(v *Value, config *Config) bool {
// match: (Mod16u x y)
// cond:
// result: (MODWU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODWU)
v.AddArg(y)
return true
}
- goto enda75d900097f1510ca1c6df786bef0c24
-enda75d900097f1510ca1c6df786bef0c24:
- ;
return false
}
func rewriteValueAMD64_OpMod32(v *Value, config *Config) bool {
// match: (Mod32 x y)
// cond:
// result: (MODL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODL)
v.AddArg(y)
return true
}
- goto end12c8c0ecf3296810b8217cd4e40f7707
-end12c8c0ecf3296810b8217cd4e40f7707:
- ;
return false
}
func rewriteValueAMD64_OpMod32u(v *Value, config *Config) bool {
// match: (Mod32u x y)
// cond:
// result: (MODLU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODLU)
v.AddArg(y)
return true
}
- goto end1f0892076cfd58733a08d3ab175a3c1c
-end1f0892076cfd58733a08d3ab175a3c1c:
- ;
return false
}
func rewriteValueAMD64_OpMod64(v *Value, config *Config) bool {
// match: (Mod64 x y)
// cond:
// result: (MODQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODQ)
v.AddArg(y)
return true
}
- goto endaae75f449baf5dc108be4e0439af97f2
-endaae75f449baf5dc108be4e0439af97f2:
- ;
return false
}
func rewriteValueAMD64_OpMod64u(v *Value, config *Config) bool {
// match: (Mod64u x y)
// cond:
// result: (MODQU x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODQU)
v.AddArg(y)
return true
}
- goto end0d4c8b9df77e59289fb14e2496559d1d
-end0d4c8b9df77e59289fb14e2496559d1d:
- ;
return false
}
func rewriteValueAMD64_OpMod8(v *Value, config *Config) bool {
// match: (Mod8 x y)
// cond:
// result: (MODW (SignExt8to16 x) (SignExt8to16 y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODW)
v.AddArg(v1)
return true
}
- goto endf959fc16e72bc6dc47ab7c9ee3778901
-endf959fc16e72bc6dc47ab7c9ee3778901:
- ;
return false
}
func rewriteValueAMD64_OpMod8u(v *Value, config *Config) bool {
// match: (Mod8u x y)
// cond:
// result: (MODWU (ZeroExt8to16 x) (ZeroExt8to16 y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MODWU)
v.AddArg(v1)
return true
}
- goto end9b3274d9dd7f1e91c75ce5e7b548fe97
-end9b3274d9dd7f1e91c75ce5e7b548fe97:
- ;
return false
}
func rewriteValueAMD64_OpMove(v *Value, config *Config) bool {
// match: (Move [0] _ _ mem)
// cond:
// result: mem
- {
+ for {
if v.AuxInt != 0 {
- goto end0961cbfe144a616cba75190d07d65e41
+ break
}
mem := v.Args[2]
v.reset(OpCopy)
v.AddArg(mem)
return true
}
- goto end0961cbfe144a616cba75190d07d65e41
-end0961cbfe144a616cba75190d07d65e41:
- ;
// match: (Move [1] dst src mem)
// cond:
// result: (MOVBstore dst (MOVBload src mem) mem)
- {
+ for {
if v.AuxInt != 1 {
- goto end72e5dd27e999493b67ea3af4ecc60d48
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(mem)
return true
}
- goto end72e5dd27e999493b67ea3af4ecc60d48
-end72e5dd27e999493b67ea3af4ecc60d48:
- ;
// match: (Move [2] dst src mem)
// cond:
// result: (MOVWstore dst (MOVWload src mem) mem)
- {
+ for {
if v.AuxInt != 2 {
- goto end017f774e406d4578b4bcefcd8db8ec1e
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(mem)
return true
}
- goto end017f774e406d4578b4bcefcd8db8ec1e
-end017f774e406d4578b4bcefcd8db8ec1e:
- ;
// match: (Move [4] dst src mem)
// cond:
// result: (MOVLstore dst (MOVLload src mem) mem)
- {
+ for {
if v.AuxInt != 4 {
- goto end938ec47a2ddf8e9b4bf71ffade6e5b3f
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(mem)
return true
}
- goto end938ec47a2ddf8e9b4bf71ffade6e5b3f
-end938ec47a2ddf8e9b4bf71ffade6e5b3f:
- ;
// match: (Move [8] dst src mem)
// cond:
// result: (MOVQstore dst (MOVQload src mem) mem)
- {
+ for {
if v.AuxInt != 8 {
- goto end696b3498f5fee17f49ae0f708d3dfe4b
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(mem)
return true
}
- goto end696b3498f5fee17f49ae0f708d3dfe4b
-end696b3498f5fee17f49ae0f708d3dfe4b:
- ;
// match: (Move [16] dst src mem)
// cond:
// result: (MOVOstore dst (MOVOload src mem) mem)
- {
+ for {
if v.AuxInt != 16 {
- goto end4894ace925d468c10a5b0c5b91fc4c1c
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(mem)
return true
}
- goto end4894ace925d468c10a5b0c5b91fc4c1c
-end4894ace925d468c10a5b0c5b91fc4c1c:
- ;
// match: (Move [3] dst src mem)
// cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem))
- {
+ for {
if v.AuxInt != 3 {
- goto end76ce0004999139fe4608c3c5356eb364
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(v1)
return true
}
- goto end76ce0004999139fe4608c3c5356eb364
-end76ce0004999139fe4608c3c5356eb364:
- ;
// match: (Move [5] dst src mem)
// cond:
// result: (MOVBstore [4] dst (MOVBload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
- {
+ for {
if v.AuxInt != 5 {
- goto end21378690c0f39bdd6b46566d57da34e3
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(v1)
return true
}
- goto end21378690c0f39bdd6b46566d57da34e3
-end21378690c0f39bdd6b46566d57da34e3:
- ;
// match: (Move [6] dst src mem)
// cond:
// result: (MOVWstore [4] dst (MOVWload [4] src mem) (MOVLstore dst (MOVLload src mem) mem))
- {
+ for {
if v.AuxInt != 6 {
- goto endcb6e509881d8638d8cae3af4f2b19a8e
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(v1)
return true
}
- goto endcb6e509881d8638d8cae3af4f2b19a8e
-endcb6e509881d8638d8cae3af4f2b19a8e:
- ;
// match: (Move [7] dst src mem)
// cond:
// result: (MOVLstore [3] dst (MOVLload [3] src mem) (MOVLstore dst (MOVLload src mem) mem))
- {
+ for {
if v.AuxInt != 7 {
- goto end3429ae54bc071c0856ad366c79b7ab97
+ break
}
dst := v.Args[0]
src := v.Args[1]
v.AddArg(v1)
return true
}
- goto end3429ae54bc071c0856ad366c79b7ab97
-end3429ae54bc071c0856ad366c79b7ab97:
- ;
// match: (Move [size] dst src mem)
// cond: size > 8 && size < 16
// result: (MOVQstore [size-8] dst (MOVQload [size-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
if !(size > 8 && size < 16) {
- goto endc90f121709d5411d389649dea89a2251
+ break
}
v.reset(OpAMD64MOVQstore)
v.AuxInt = size - 8
v.AddArg(v1)
return true
}
- goto endc90f121709d5411d389649dea89a2251
-endc90f121709d5411d389649dea89a2251:
- ;
// match: (Move [size] dst src mem)
// cond: size > 16 && size%16 != 0 && size%16 <= 8
// result: (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16]) (MOVQstore dst (MOVQload src mem) mem))
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
if !(size > 16 && size%16 != 0 && size%16 <= 8) {
- goto end376c57db23b866866f23677c6cde43ba
+ break
}
v.reset(OpMove)
v.AuxInt = size - size%16
v.AddArg(v2)
return true
}
- goto end376c57db23b866866f23677c6cde43ba
-end376c57db23b866866f23677c6cde43ba:
- ;
// match: (Move [size] dst src mem)
// cond: size > 16 && size%16 != 0 && size%16 > 8
// result: (Move [size-size%16] (ADDQconst <dst.Type> dst [size%16]) (ADDQconst <src.Type> src [size%16]) (MOVOstore dst (MOVOload src mem) mem))
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
if !(size > 16 && size%16 != 0 && size%16 > 8) {
- goto end2f82f76766a21f8802768380cf10a497
+ break
}
v.reset(OpMove)
v.AuxInt = size - size%16
v.AddArg(v2)
return true
}
- goto end2f82f76766a21f8802768380cf10a497
-end2f82f76766a21f8802768380cf10a497:
- ;
// match: (Move [size] dst src mem)
// cond: size >= 32 && size <= 16*64 && size%16 == 0
// result: (DUFFCOPY [14*(64-size/16)] dst src mem)
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
if !(size >= 32 && size <= 16*64 && size%16 == 0) {
- goto endcb66da6685f0079ee1f84d10fa561f22
+ break
}
v.reset(OpAMD64DUFFCOPY)
v.AuxInt = 14 * (64 - size/16)
v.AddArg(mem)
return true
}
- goto endcb66da6685f0079ee1f84d10fa561f22
-endcb66da6685f0079ee1f84d10fa561f22:
- ;
// match: (Move [size] dst src mem)
// cond: size > 16*64 && size%8 == 0
// result: (REPMOVSQ dst src (MOVQconst [size/8]) mem)
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
src := v.Args[1]
mem := v.Args[2]
if !(size > 16*64 && size%8 == 0) {
- goto end7ae25ff1bbdcf34efef09613745e9d6e
+ break
}
v.reset(OpAMD64REPMOVSQ)
v.AddArg(dst)
v.AddArg(mem)
return true
}
- goto end7ae25ff1bbdcf34efef09613745e9d6e
-end7ae25ff1bbdcf34efef09613745e9d6e:
- ;
return false
}
func rewriteValueAMD64_OpMul16(v *Value, config *Config) bool {
// match: (Mul16 x y)
// cond:
// result: (MULW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULW)
v.AddArg(y)
return true
}
- goto end1addf5ea2c885aa1729b8f944859d00c
-end1addf5ea2c885aa1729b8f944859d00c:
- ;
return false
}
func rewriteValueAMD64_OpMul32(v *Value, config *Config) bool {
// match: (Mul32 x y)
// cond:
// result: (MULL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULL)
v.AddArg(y)
return true
}
- goto ende144381f85808e5144782804768e2859
-ende144381f85808e5144782804768e2859:
- ;
return false
}
func rewriteValueAMD64_OpMul32F(v *Value, config *Config) bool {
// match: (Mul32F x y)
// cond:
// result: (MULSS x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULSS)
v.AddArg(y)
return true
}
- goto end32105a3bfe0237b799b69d83b3f171ca
-end32105a3bfe0237b799b69d83b3f171ca:
- ;
return false
}
func rewriteValueAMD64_OpMul64(v *Value, config *Config) bool {
// match: (Mul64 x y)
// cond:
// result: (MULQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULQ)
v.AddArg(y)
return true
}
- goto end38da21e77ac329eb643b20e7d97d5853
-end38da21e77ac329eb643b20e7d97d5853:
- ;
return false
}
func rewriteValueAMD64_OpMul64F(v *Value, config *Config) bool {
// match: (Mul64F x y)
// cond:
// result: (MULSD x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULSD)
v.AddArg(y)
return true
}
- goto end0ff6e1919fb0a3e549eb82b43edf1f52
-end0ff6e1919fb0a3e549eb82b43edf1f52:
- ;
return false
}
func rewriteValueAMD64_OpMul8(v *Value, config *Config) bool {
// match: (Mul8 x y)
// cond:
// result: (MULB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64MULB)
v.AddArg(y)
return true
}
- goto endd876d6bc42a2285b801f42dadbd8757c
-endd876d6bc42a2285b801f42dadbd8757c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NEGB(v *Value, config *Config) bool {
// match: (NEGB (MOVBconst [c]))
// cond:
// result: (MOVBconst [-c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end36d0300ba9eab8c9da86246ff653ca96
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = -c
return true
}
- goto end36d0300ba9eab8c9da86246ff653ca96
-end36d0300ba9eab8c9da86246ff653ca96:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NEGL(v *Value, config *Config) bool {
// match: (NEGL (MOVLconst [c]))
// cond:
// result: (MOVLconst [-c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end7a245ec67e56bd51911e5ba2d0aa0a16
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = -c
return true
}
- goto end7a245ec67e56bd51911e5ba2d0aa0a16
-end7a245ec67e56bd51911e5ba2d0aa0a16:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NEGQ(v *Value, config *Config) bool {
// match: (NEGQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [-c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end04ddd98bc6724ecb85c80c2a4e2bca5a
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = -c
return true
}
- goto end04ddd98bc6724ecb85c80c2a4e2bca5a
-end04ddd98bc6724ecb85c80c2a4e2bca5a:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NEGW(v *Value, config *Config) bool {
// match: (NEGW (MOVWconst [c]))
// cond:
// result: (MOVWconst [-c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end1db6636f0a51848d8a34f6561ecfe7ae
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = -c
return true
}
- goto end1db6636f0a51848d8a34f6561ecfe7ae
-end1db6636f0a51848d8a34f6561ecfe7ae:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NOTB(v *Value, config *Config) bool {
// match: (NOTB (MOVBconst [c]))
// cond:
// result: (MOVBconst [^c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end9e383a9ceb29a9e2bf890ec6a67212a8
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = ^c
return true
}
- goto end9e383a9ceb29a9e2bf890ec6a67212a8
-end9e383a9ceb29a9e2bf890ec6a67212a8:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NOTL(v *Value, config *Config) bool {
// match: (NOTL (MOVLconst [c]))
// cond:
// result: (MOVLconst [^c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endcc73972c088d5e652a1370a96e56502d
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = ^c
return true
}
- goto endcc73972c088d5e652a1370a96e56502d
-endcc73972c088d5e652a1370a96e56502d:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NOTQ(v *Value, config *Config) bool {
// match: (NOTQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [^c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endb39ddb6bf7339d46f74114baad4333b6
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = ^c
return true
}
- goto endb39ddb6bf7339d46f74114baad4333b6
-endb39ddb6bf7339d46f74114baad4333b6:
- ;
return false
}
func rewriteValueAMD64_OpAMD64NOTW(v *Value, config *Config) bool {
// match: (NOTW (MOVWconst [c]))
// cond:
// result: (MOVWconst [^c])
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end35848095ebcf894c6957ad3be5f82c43
+ break
}
c := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = ^c
return true
}
- goto end35848095ebcf894c6957ad3be5f82c43
-end35848095ebcf894c6957ad3be5f82c43:
- ;
return false
}
func rewriteValueAMD64_OpNeg16(v *Value, config *Config) bool {
// match: (Neg16 x)
// cond:
// result: (NEGW x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NEGW)
v.AddArg(x)
return true
}
- goto end7a8c652f4ffeb49656119af69512edb2
-end7a8c652f4ffeb49656119af69512edb2:
- ;
return false
}
func rewriteValueAMD64_OpNeg32(v *Value, config *Config) bool {
// match: (Neg32 x)
// cond:
// result: (NEGL x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NEGL)
v.AddArg(x)
return true
}
- goto endce1f7e17fc193f6c076e47d5e401e126
-endce1f7e17fc193f6c076e47d5e401e126:
- ;
return false
}
func rewriteValueAMD64_OpNeg32F(v *Value, config *Config) bool {
// match: (Neg32F x)
// cond:
// result: (PXOR x (MOVSSconst <config.Frontend().TypeFloat32()> [f2i(math.Copysign(0, -1))]))
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64PXOR)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end685a5fc899e195b9091afbe2a7146051
-end685a5fc899e195b9091afbe2a7146051:
- ;
return false
}
func rewriteValueAMD64_OpNeg64(v *Value, config *Config) bool {
// match: (Neg64 x)
// cond:
// result: (NEGQ x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NEGQ)
v.AddArg(x)
return true
}
- goto enda06c5b1718f2b96aba10bf5a5c437c6c
-enda06c5b1718f2b96aba10bf5a5c437c6c:
- ;
return false
}
func rewriteValueAMD64_OpNeg64F(v *Value, config *Config) bool {
// match: (Neg64F x)
// cond:
// result: (PXOR x (MOVSDconst <config.Frontend().TypeFloat64()> [f2i(math.Copysign(0, -1))]))
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64PXOR)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto ende85ae82b7a51e75000eb9158d584acb2
-ende85ae82b7a51e75000eb9158d584acb2:
- ;
return false
}
func rewriteValueAMD64_OpNeg8(v *Value, config *Config) bool {
// match: (Neg8 x)
// cond:
// result: (NEGB x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64NEGB)
v.AddArg(x)
return true
}
- goto end1e5f495a2ac6cdea47b1ae5ba62aa95d
-end1e5f495a2ac6cdea47b1ae5ba62aa95d:
- ;
return false
}
func rewriteValueAMD64_OpNeq16(v *Value, config *Config) bool {
// match: (Neq16 x y)
// cond:
// result: (SETNE (CMPW x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNE)
v.AddArg(v0)
return true
}
- goto end6413ee42d523a005cce9e3372ff2c8e9
-end6413ee42d523a005cce9e3372ff2c8e9:
- ;
return false
}
func rewriteValueAMD64_OpNeq32(v *Value, config *Config) bool {
// match: (Neq32 x y)
// cond:
// result: (SETNE (CMPL x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNE)
v.AddArg(v0)
return true
}
- goto endb1a3ad499a09d8262952e6cbc47a23a8
-endb1a3ad499a09d8262952e6cbc47a23a8:
- ;
return false
}
func rewriteValueAMD64_OpNeq32F(v *Value, config *Config) bool {
// match: (Neq32F x y)
// cond:
// result: (SETNEF (UCOMISS x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNEF)
v.AddArg(v0)
return true
}
- goto end2a001b2774f58aaf8c1e9efce6ae59e7
-end2a001b2774f58aaf8c1e9efce6ae59e7:
- ;
return false
}
func rewriteValueAMD64_OpNeq64(v *Value, config *Config) bool {
// match: (Neq64 x y)
// cond:
// result: (SETNE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNE)
v.AddArg(v0)
return true
}
- goto end092b9159bce08d2ef7896f7d3da5a595
-end092b9159bce08d2ef7896f7d3da5a595:
- ;
return false
}
func rewriteValueAMD64_OpNeq64F(v *Value, config *Config) bool {
// match: (Neq64F x y)
// cond:
// result: (SETNEF (UCOMISD x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNEF)
v.AddArg(v0)
return true
}
- goto endb9c010023c38bd2fee7800fbefc85d98
-endb9c010023c38bd2fee7800fbefc85d98:
- ;
return false
}
func rewriteValueAMD64_OpNeq8(v *Value, config *Config) bool {
// match: (Neq8 x y)
// cond:
// result: (SETNE (CMPB x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNE)
v.AddArg(v0)
return true
}
- goto end89e59f45e068c89458cc4db1692bf3bb
-end89e59f45e068c89458cc4db1692bf3bb:
- ;
return false
}
func rewriteValueAMD64_OpNeqPtr(v *Value, config *Config) bool {
// match: (NeqPtr x y)
// cond:
// result: (SETNE (CMPQ x y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SETNE)
v.AddArg(v0)
return true
}
- goto end3b8bb3b4952011d1d40f993d8717cf16
-end3b8bb3b4952011d1d40f993d8717cf16:
- ;
return false
}
func rewriteValueAMD64_OpNilCheck(v *Value, config *Config) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
- {
+ for {
ptr := v.Args[0]
mem := v.Args[1]
v.reset(OpAMD64LoweredNilCheck)
v.AddArg(mem)
return true
}
- goto end75520e60179564948a625707b84e8a8d
-end75520e60179564948a625707b84e8a8d:
- ;
return false
}
func rewriteValueAMD64_OpNot(v *Value, config *Config) bool {
// match: (Not x)
// cond:
// result: (XORBconst [1] x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64XORBconst)
v.AuxInt = 1
v.AddArg(x)
return true
}
- goto end73973101aad60079c62fa64624e21db1
-end73973101aad60079c62fa64624e21db1:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORB(v *Value, config *Config) bool {
// match: (ORB x (MOVBconst [c]))
// cond:
// result: (ORBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end7b63870decde2515cb77ec4f8f76817c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ORBconst)
v.AddArg(x)
return true
}
- goto end7b63870decde2515cb77ec4f8f76817c
-end7b63870decde2515cb77ec4f8f76817c:
- ;
// match: (ORB (MOVBconst [c]) x)
// cond:
// result: (ORBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end70b43d531e2097a4f6293f66256a642e
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end70b43d531e2097a4f6293f66256a642e
-end70b43d531e2097a4f6293f66256a642e:
- ;
// match: (ORB x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto enddca5ce800a9eca157f243cb2fdb1408a
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto enddca5ce800a9eca157f243cb2fdb1408a
-enddca5ce800a9eca157f243cb2fdb1408a:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORBconst(v *Value, config *Config) bool {
// match: (ORBconst [c] x)
// cond: int8(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int8(c) == 0) {
- goto end565f78e3a843dc73943b59227b39a1b3
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end565f78e3a843dc73943b59227b39a1b3
-end565f78e3a843dc73943b59227b39a1b3:
- ;
// match: (ORBconst [c] _)
// cond: int8(c)==-1
// result: (MOVBconst [-1])
- {
+ for {
c := v.AuxInt
if !(int8(c) == -1) {
- goto end6033c7910d8cd536b31446e179e4610d
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = -1
return true
}
- goto end6033c7910d8cd536b31446e179e4610d
-end6033c7910d8cd536b31446e179e4610d:
- ;
// match: (ORBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [c|d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endbe5263f022dc10a5cf53c118937d79dd
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = c | d
return true
}
- goto endbe5263f022dc10a5cf53c118937d79dd
-endbe5263f022dc10a5cf53c118937d79dd:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORL(v *Value, config *Config) bool {
// match: (ORL x (MOVLconst [c]))
// cond:
// result: (ORLconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end1b883e30d860b6fac14ae98462c4f61a
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ORLconst)
v.AddArg(x)
return true
}
- goto end1b883e30d860b6fac14ae98462c4f61a
-end1b883e30d860b6fac14ae98462c4f61a:
- ;
// match: (ORL (MOVLconst [c]) x)
// cond:
// result: (ORLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto enda5bc49524a0cbd2241f792837d0a48a8
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto enda5bc49524a0cbd2241f792837d0a48a8
-enda5bc49524a0cbd2241f792837d0a48a8:
- ;
// match: (ORL x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end2dd719b68f4938777ef0d820aab93659
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end2dd719b68f4938777ef0d820aab93659
-end2dd719b68f4938777ef0d820aab93659:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORLconst(v *Value, config *Config) bool {
// match: (ORLconst [c] x)
// cond: int32(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int32(c) == 0) {
- goto end5b52623a724e8a7167c71289fb7192f1
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end5b52623a724e8a7167c71289fb7192f1
-end5b52623a724e8a7167c71289fb7192f1:
- ;
// match: (ORLconst [c] _)
// cond: int32(c)==-1
// result: (MOVLconst [-1])
- {
+ for {
c := v.AuxInt
if !(int32(c) == -1) {
- goto end345a8ea439ef2ef54bd84fc8a0f73e97
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = -1
return true
}
- goto end345a8ea439ef2ef54bd84fc8a0f73e97
-end345a8ea439ef2ef54bd84fc8a0f73e97:
- ;
// match: (ORLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [c|d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto ende9ca05024248f782c88084715f81d727
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = c | d
return true
}
- goto ende9ca05024248f782c88084715f81d727
-ende9ca05024248f782c88084715f81d727:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORQ(v *Value, config *Config) bool {
// match: (ORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ORQconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end601f2bb3ccda102e484ff60adeaf6d26
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end601f2bb3ccda102e484ff60adeaf6d26
+ break
}
v.reset(OpAMD64ORQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end601f2bb3ccda102e484ff60adeaf6d26
-end601f2bb3ccda102e484ff60adeaf6d26:
- ;
// match: (ORQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (ORQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end010afbebcd314e288509d79a16a6d5cc
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto end010afbebcd314e288509d79a16a6d5cc
+ break
}
v.reset(OpAMD64ORQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end010afbebcd314e288509d79a16a6d5cc
-end010afbebcd314e288509d79a16a6d5cc:
- ;
// match: (ORQ x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end47a27d30b82db576978c5a3a57b520fb
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end47a27d30b82db576978c5a3a57b520fb
-end47a27d30b82db576978c5a3a57b520fb:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORQconst(v *Value, config *Config) bool {
// match: (ORQconst [0] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto end44534da6b9ce98d33fad7e20f0be1fbd
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end44534da6b9ce98d33fad7e20f0be1fbd
-end44534da6b9ce98d33fad7e20f0be1fbd:
- ;
// match: (ORQconst [-1] _)
// cond:
// result: (MOVQconst [-1])
- {
+ for {
if v.AuxInt != -1 {
- goto endcde9b9d7c4527eaa5d50b252f50b43c1
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = -1
return true
}
- goto endcde9b9d7c4527eaa5d50b252f50b43c1
-endcde9b9d7c4527eaa5d50b252f50b43c1:
- ;
// match: (ORQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [c|d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto enda2488509b71db9abcb06a5115c4ddc2c
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = c | d
return true
}
- goto enda2488509b71db9abcb06a5115c4ddc2c
-enda2488509b71db9abcb06a5115c4ddc2c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORW(v *Value, config *Config) bool {
// match: (ORW x (MOVWconst [c]))
// cond:
// result: (ORWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end9f98df10892dbf170b49aace86ee0d7f
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64ORWconst)
v.AddArg(x)
return true
}
- goto end9f98df10892dbf170b49aace86ee0d7f
-end9f98df10892dbf170b49aace86ee0d7f:
- ;
// match: (ORW (MOVWconst [c]) x)
// cond:
// result: (ORWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end96405942c9ceb5fcb0ddb85a8709d015
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end96405942c9ceb5fcb0ddb85a8709d015
-end96405942c9ceb5fcb0ddb85a8709d015:
- ;
// match: (ORW x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endc6a23b64e541dc9cfc6a90fd7028e8c1
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endc6a23b64e541dc9cfc6a90fd7028e8c1
-endc6a23b64e541dc9cfc6a90fd7028e8c1:
- ;
return false
}
func rewriteValueAMD64_OpAMD64ORWconst(v *Value, config *Config) bool {
// match: (ORWconst [c] x)
// cond: int16(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int16(c) == 0) {
- goto endbbbdec9091c8b4c58e587eac8a43402d
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endbbbdec9091c8b4c58e587eac8a43402d
-endbbbdec9091c8b4c58e587eac8a43402d:
- ;
// match: (ORWconst [c] _)
// cond: int16(c)==-1
// result: (MOVWconst [-1])
- {
+ for {
c := v.AuxInt
if !(int16(c) == -1) {
- goto ended87a5775f5e04b2d2a117a63d82dd9b
+ break
}
v.reset(OpAMD64MOVWconst)
v.AuxInt = -1
return true
}
- goto ended87a5775f5e04b2d2a117a63d82dd9b
-ended87a5775f5e04b2d2a117a63d82dd9b:
- ;
// match: (ORWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [c|d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto endba9221a8462b5c62e8d7c686f64c2778
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = c | d
return true
}
- goto endba9221a8462b5c62e8d7c686f64c2778
-endba9221a8462b5c62e8d7c686f64c2778:
- ;
return false
}
func rewriteValueAMD64_OpOffPtr(v *Value, config *Config) bool {
// match: (OffPtr [off] ptr)
// cond:
// result: (ADDQconst [off] ptr)
- {
+ for {
off := v.AuxInt
ptr := v.Args[0]
v.reset(OpAMD64ADDQconst)
v.AddArg(ptr)
return true
}
- goto end0429f947ee7ac49ff45a243e461a5290
-end0429f947ee7ac49ff45a243e461a5290:
- ;
return false
}
func rewriteValueAMD64_OpOr16(v *Value, config *Config) bool {
// match: (Or16 x y)
// cond:
// result: (ORW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ORW)
v.AddArg(y)
return true
}
- goto end8fedf2c79d5607b7056b0ff015199cbd
-end8fedf2c79d5607b7056b0ff015199cbd:
- ;
return false
}
func rewriteValueAMD64_OpOr32(v *Value, config *Config) bool {
// match: (Or32 x y)
// cond:
// result: (ORL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ORL)
v.AddArg(y)
return true
}
- goto endea45bed9ca97d2995b68b53e6012d384
-endea45bed9ca97d2995b68b53e6012d384:
- ;
return false
}
func rewriteValueAMD64_OpOr64(v *Value, config *Config) bool {
// match: (Or64 x y)
// cond:
// result: (ORQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ORQ)
v.AddArg(y)
return true
}
- goto end3a446becaf2461f4f1a41faeef313f41
-end3a446becaf2461f4f1a41faeef313f41:
- ;
return false
}
func rewriteValueAMD64_OpOr8(v *Value, config *Config) bool {
// match: (Or8 x y)
// cond:
// result: (ORB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64ORB)
v.AddArg(y)
return true
}
- goto end6f8a8c559a167d1f0a5901d09a1fb248
-end6f8a8c559a167d1f0a5901d09a1fb248:
- ;
return false
}
func rewriteValueAMD64_OpRsh16Ux16(v *Value, config *Config) bool {
// match: (Rsh16Ux16 <t> x y)
// cond:
// result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPWconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end291acf0117b46a676e5e1fe524459800
-end291acf0117b46a676e5e1fe524459800:
- ;
return false
}
func rewriteValueAMD64_OpRsh16Ux32(v *Value, config *Config) bool {
// match: (Rsh16Ux32 <t> x y)
// cond:
// result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPLconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endea051fe538151b144cd630ce63d35bf7
-endea051fe538151b144cd630ce63d35bf7:
- ;
return false
}
func rewriteValueAMD64_OpRsh16Ux64(v *Value, config *Config) bool {
// match: (Rsh16Ux64 <t> x y)
// cond:
// result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPQconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endd1a8f3aa91391fbd13c2dcd03a75283a
-endd1a8f3aa91391fbd13c2dcd03a75283a:
- ;
return false
}
func rewriteValueAMD64_OpRsh16Ux8(v *Value, config *Config) bool {
// match: (Rsh16Ux8 <t> x y)
// cond:
// result: (ANDW (SHRW <t> x y) (SBBLcarrymask <t> (CMPBconst y [16])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end9de32652fceccadca5a6206066bcbb10
-end9de32652fceccadca5a6206066bcbb10:
- ;
return false
}
func rewriteValueAMD64_OpRsh16x16(v *Value, config *Config) bool {
// match: (Rsh16x16 <t> x y)
// cond:
// result: (SARW <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [16])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end71e3cf43426d4351f7fac15145ca6cd9
-end71e3cf43426d4351f7fac15145ca6cd9:
- ;
return false
}
func rewriteValueAMD64_OpRsh16x32(v *Value, config *Config) bool {
// match: (Rsh16x32 <t> x y)
// cond:
// result: (SARW <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [16])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endfc3bf56711046c6b29b676b155af7c98
-endfc3bf56711046c6b29b676b155af7c98:
- ;
return false
}
func rewriteValueAMD64_OpRsh16x64(v *Value, config *Config) bool {
// match: (Rsh16x64 <t> x y)
// cond:
// result: (SARW <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [16])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endeaf40562fd3394586c63adceca4d9559
-endeaf40562fd3394586c63adceca4d9559:
- ;
return false
}
func rewriteValueAMD64_OpRsh16x8(v *Value, config *Config) bool {
// match: (Rsh16x8 <t> x y)
// cond:
// result: (SARW <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [16])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endc6cd0d3ecc71bc1830e01c07f274ff7b
-endc6cd0d3ecc71bc1830e01c07f274ff7b:
- ;
return false
}
func rewriteValueAMD64_OpRsh32Ux16(v *Value, config *Config) bool {
// match: (Rsh32Ux16 <t> x y)
// cond:
// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPWconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end74ddc1443f6ffb1fe911f455ff982bfb
-end74ddc1443f6ffb1fe911f455ff982bfb:
- ;
return false
}
func rewriteValueAMD64_OpRsh32Ux32(v *Value, config *Config) bool {
// match: (Rsh32Ux32 <t> x y)
// cond:
// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPLconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto enda93828d8aa54be68080640034f94ed96
-enda93828d8aa54be68080640034f94ed96:
- ;
return false
}
func rewriteValueAMD64_OpRsh32Ux64(v *Value, config *Config) bool {
// match: (Rsh32Ux64 <t> x y)
// cond:
// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPQconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end4f644f3f89ef842f4b0567fc385a58e3
-end4f644f3f89ef842f4b0567fc385a58e3:
- ;
return false
}
func rewriteValueAMD64_OpRsh32Ux8(v *Value, config *Config) bool {
// match: (Rsh32Ux8 <t> x y)
// cond:
// result: (ANDL (SHRL <t> x y) (SBBLcarrymask <t> (CMPBconst y [32])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end2a8f279bb4900b9bf3846378f36d7994
-end2a8f279bb4900b9bf3846378f36d7994:
- ;
return false
}
func rewriteValueAMD64_OpRsh32x16(v *Value, config *Config) bool {
// match: (Rsh32x16 <t> x y)
// cond:
// result: (SARL <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [32])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end1b3a698a50c89c656aa6f7acd72e3f5e
-end1b3a698a50c89c656aa6f7acd72e3f5e:
- ;
return false
}
func rewriteValueAMD64_OpRsh32x32(v *Value, config *Config) bool {
// match: (Rsh32x32 <t> x y)
// cond:
// result: (SARL <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [32])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endc6596de1c198fd84c4076aaa3c6486e5
-endc6596de1c198fd84c4076aaa3c6486e5:
- ;
return false
}
func rewriteValueAMD64_OpRsh32x64(v *Value, config *Config) bool {
// match: (Rsh32x64 <t> x y)
// cond:
// result: (SARL <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [32])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto enddda2e730607e2d13b18f1006316e0ebb
-enddda2e730607e2d13b18f1006316e0ebb:
- ;
return false
}
func rewriteValueAMD64_OpRsh32x8(v *Value, config *Config) bool {
// match: (Rsh32x8 <t> x y)
// cond:
// result: (SARL <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [32])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endd9cb28c7e3a43fbd7a877750f34df72a
-endd9cb28c7e3a43fbd7a877750f34df72a:
- ;
return false
}
func rewriteValueAMD64_OpRsh64Ux16(v *Value, config *Config) bool {
// match: (Rsh64Ux16 <t> x y)
// cond:
// result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPWconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end04dfdfa8a2dcffaf7ab1ee93a96b8677
-end04dfdfa8a2dcffaf7ab1ee93a96b8677:
- ;
return false
}
func rewriteValueAMD64_OpRsh64Ux32(v *Value, config *Config) bool {
// match: (Rsh64Ux32 <t> x y)
// cond:
// result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPLconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end2b2f03d14fb01fd490115a96d893ddb3
-end2b2f03d14fb01fd490115a96d893ddb3:
- ;
return false
}
func rewriteValueAMD64_OpRsh64Ux64(v *Value, config *Config) bool {
// match: (Rsh64Ux64 <t> x y)
// cond:
// result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPQconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endb24ca32f261a5c799d3e5a572f7cdcff
-endb24ca32f261a5c799d3e5a572f7cdcff:
- ;
return false
}
func rewriteValueAMD64_OpRsh64Ux8(v *Value, config *Config) bool {
// match: (Rsh64Ux8 <t> x y)
// cond:
// result: (ANDQ (SHRQ <t> x y) (SBBQcarrymask <t> (CMPBconst y [64])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end05a9a99310c9e282df012d5c48b58475
-end05a9a99310c9e282df012d5c48b58475:
- ;
return false
}
func rewriteValueAMD64_OpRsh64x16(v *Value, config *Config) bool {
// match: (Rsh64x16 <t> x y)
// cond:
// result: (SARQ <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [64])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto endb97b88b7c4e431bd64ced5690f0e85c4
-endb97b88b7c4e431bd64ced5690f0e85c4:
- ;
return false
}
func rewriteValueAMD64_OpRsh64x32(v *Value, config *Config) bool {
// match: (Rsh64x32 <t> x y)
// cond:
// result: (SARQ <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [64])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end95f72c0d315e6b1d70015b31a0f5f4ca
-end95f72c0d315e6b1d70015b31a0f5f4ca:
- ;
return false
}
func rewriteValueAMD64_OpRsh64x64(v *Value, config *Config) bool {
// match: (Rsh64x64 <t> x y)
// cond:
// result: (SARQ <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [64])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto enda8ddfaa8e519c0ed70c344a136ba9126
-enda8ddfaa8e519c0ed70c344a136ba9126:
- ;
return false
}
func rewriteValueAMD64_OpRsh64x8(v *Value, config *Config) bool {
// match: (Rsh64x8 <t> x y)
// cond:
// result: (SARQ <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [64])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end62f4adae0bbd0c4d5d6eb7d5eda6a5e3
-end62f4adae0bbd0c4d5d6eb7d5eda6a5e3:
- ;
return false
}
func rewriteValueAMD64_OpRsh8Ux16(v *Value, config *Config) bool {
// match: (Rsh8Ux16 <t> x y)
// cond:
// result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPWconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto endb791c8283bd486da9809520a7262d5ba
-endb791c8283bd486da9809520a7262d5ba:
- ;
return false
}
func rewriteValueAMD64_OpRsh8Ux32(v *Value, config *Config) bool {
// match: (Rsh8Ux32 <t> x y)
// cond:
// result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPLconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end5f360ab34942dc218e8f75624c86bbb2
-end5f360ab34942dc218e8f75624c86bbb2:
- ;
return false
}
func rewriteValueAMD64_OpRsh8Ux64(v *Value, config *Config) bool {
// match: (Rsh8Ux64 <t> x y)
// cond:
// result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPQconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end7138df590f00234cd21cf02da8ed109e
-end7138df590f00234cd21cf02da8ed109e:
- ;
return false
}
func rewriteValueAMD64_OpRsh8Ux8(v *Value, config *Config) bool {
// match: (Rsh8Ux8 <t> x y)
// cond:
// result: (ANDB (SHRB <t> x y) (SBBLcarrymask <t> (CMPBconst y [8])))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v1)
return true
}
- goto end3aab873310bf7b2f3f90705fbd082b93
-end3aab873310bf7b2f3f90705fbd082b93:
- ;
return false
}
func rewriteValueAMD64_OpRsh8x16(v *Value, config *Config) bool {
// match: (Rsh8x16 <t> x y)
// cond:
// result: (SARB <t> x (ORW <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPWconst y [8])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto ende275bad06ac788b484b038f1bb3afc8d
-ende275bad06ac788b484b038f1bb3afc8d:
- ;
return false
}
func rewriteValueAMD64_OpRsh8x32(v *Value, config *Config) bool {
// match: (Rsh8x32 <t> x y)
// cond:
// result: (SARB <t> x (ORL <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPLconst y [8])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end00833cba5173dc390952b6c4644af376
-end00833cba5173dc390952b6c4644af376:
- ;
return false
}
func rewriteValueAMD64_OpRsh8x64(v *Value, config *Config) bool {
// match: (Rsh8x64 <t> x y)
// cond:
// result: (SARB <t> x (ORQ <y.Type> y (NOTQ <y.Type> (SBBQcarrymask <y.Type> (CMPQconst y [8])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end039cf4d3a939b89164b058d09f532fb5
-end039cf4d3a939b89164b058d09f532fb5:
- ;
return false
}
func rewriteValueAMD64_OpRsh8x8(v *Value, config *Config) bool {
// match: (Rsh8x8 <t> x y)
// cond:
// result: (SARB <t> x (ORB <y.Type> y (NOTL <y.Type> (SBBLcarrymask <y.Type> (CMPBconst y [8])))))
- {
+ for {
t := v.Type
x := v.Args[0]
y := v.Args[1]
v.AddArg(v0)
return true
}
- goto end6453a48c573d0dc7c8b0163a266c6218
-end6453a48c573d0dc7c8b0163a266c6218:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARB(v *Value, config *Config) bool {
// match: (SARB x (MOVQconst [c]))
// cond:
// result: (SARBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end03194336f801b91c1423aed6f39247f0
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARBconst)
v.AddArg(x)
return true
}
- goto end03194336f801b91c1423aed6f39247f0
-end03194336f801b91c1423aed6f39247f0:
- ;
// match: (SARB x (MOVLconst [c]))
// cond:
// result: (SARBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end3f623e78dd789403b299106625e0d6df
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARBconst)
v.AddArg(x)
return true
}
- goto end3f623e78dd789403b299106625e0d6df
-end3f623e78dd789403b299106625e0d6df:
- ;
// match: (SARB x (MOVWconst [c]))
// cond:
// result: (SARBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end4393e26c64e39342a0634d9a5706cb10
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARBconst)
v.AddArg(x)
return true
}
- goto end4393e26c64e39342a0634d9a5706cb10
-end4393e26c64e39342a0634d9a5706cb10:
- ;
// match: (SARB x (MOVBconst [c]))
// cond:
// result: (SARBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end3bf3d17717aa6c04462e56d1c87902ce
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARBconst)
v.AddArg(x)
return true
}
- goto end3bf3d17717aa6c04462e56d1c87902ce
-end3bf3d17717aa6c04462e56d1c87902ce:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARBconst(v *Value, config *Config) bool {
// match: (SARBconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [d>>uint64(c)])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end06e0e38775f0650ed672427d19cd8fff
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = d >> uint64(c)
return true
}
- goto end06e0e38775f0650ed672427d19cd8fff
-end06e0e38775f0650ed672427d19cd8fff:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARL(v *Value, config *Config) bool {
// match: (SARL x (MOVQconst [c]))
// cond:
// result: (SARLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end8fb4e77be1f4d21d0f2a0facf9a60add
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARLconst)
v.AddArg(x)
return true
}
- goto end8fb4e77be1f4d21d0f2a0facf9a60add
-end8fb4e77be1f4d21d0f2a0facf9a60add:
- ;
// match: (SARL x (MOVLconst [c]))
// cond:
// result: (SARLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto ende586a72c1b232ee0b63e37c71eeb8470
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARLconst)
v.AddArg(x)
return true
}
- goto ende586a72c1b232ee0b63e37c71eeb8470
-ende586a72c1b232ee0b63e37c71eeb8470:
- ;
// match: (SARL x (MOVWconst [c]))
// cond:
// result: (SARLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end37389c13b9fb94c44bd10b1143809afb
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARLconst)
v.AddArg(x)
return true
}
- goto end37389c13b9fb94c44bd10b1143809afb
-end37389c13b9fb94c44bd10b1143809afb:
- ;
// match: (SARL x (MOVBconst [c]))
// cond:
// result: (SARLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end72550eb8c44c45e76e40888bce753160
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARLconst)
v.AddArg(x)
return true
}
- goto end72550eb8c44c45e76e40888bce753160
-end72550eb8c44c45e76e40888bce753160:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARLconst(v *Value, config *Config) bool {
// match: (SARLconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [d>>uint64(c)])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end8f34dc94323303e75b7bcc8e731cf1db
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = d >> uint64(c)
return true
}
- goto end8f34dc94323303e75b7bcc8e731cf1db
-end8f34dc94323303e75b7bcc8e731cf1db:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARQ(v *Value, config *Config) bool {
// match: (SARQ x (MOVQconst [c]))
// cond:
// result: (SARQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end25e720ab203be2745dded5550e6d8a7c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARQconst)
v.AddArg(x)
return true
}
- goto end25e720ab203be2745dded5550e6d8a7c
-end25e720ab203be2745dded5550e6d8a7c:
- ;
// match: (SARQ x (MOVLconst [c]))
// cond:
// result: (SARQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto endd04cf826c5db444107cf4e0bf789bcda
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARQconst)
v.AddArg(x)
return true
}
- goto endd04cf826c5db444107cf4e0bf789bcda
-endd04cf826c5db444107cf4e0bf789bcda:
- ;
// match: (SARQ x (MOVWconst [c]))
// cond:
// result: (SARQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end6266051b3a126922286c298594535622
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARQconst)
v.AddArg(x)
return true
}
- goto end6266051b3a126922286c298594535622
-end6266051b3a126922286c298594535622:
- ;
// match: (SARQ x (MOVBconst [c]))
// cond:
// result: (SARQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endcf2a1bdfeda535fc96ae1e7f5c54d531
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARQconst)
v.AddArg(x)
return true
}
- goto endcf2a1bdfeda535fc96ae1e7f5c54d531
-endcf2a1bdfeda535fc96ae1e7f5c54d531:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARQconst(v *Value, config *Config) bool {
// match: (SARQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [d>>uint64(c)])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endd949ba69a1ff71ba62c49b39c68f269e
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = d >> uint64(c)
return true
}
- goto endd949ba69a1ff71ba62c49b39c68f269e
-endd949ba69a1ff71ba62c49b39c68f269e:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARW(v *Value, config *Config) bool {
// match: (SARW x (MOVQconst [c]))
// cond:
// result: (SARWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto endec8cafea5ff91b2a1b5cf5a169be924f
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARWconst)
v.AddArg(x)
return true
}
- goto endec8cafea5ff91b2a1b5cf5a169be924f
-endec8cafea5ff91b2a1b5cf5a169be924f:
- ;
// match: (SARW x (MOVLconst [c]))
// cond:
// result: (SARWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end9303d0edeebdc8a2a7e93fecf0fff61c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARWconst)
v.AddArg(x)
return true
}
- goto end9303d0edeebdc8a2a7e93fecf0fff61c
-end9303d0edeebdc8a2a7e93fecf0fff61c:
- ;
// match: (SARW x (MOVWconst [c]))
// cond:
// result: (SARWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto endc46e3f211f94238f9a0aec3c498af490
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARWconst)
v.AddArg(x)
return true
}
- goto endc46e3f211f94238f9a0aec3c498af490
-endc46e3f211f94238f9a0aec3c498af490:
- ;
// match: (SARW x (MOVBconst [c]))
// cond:
// result: (SARWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end0bf07ce9cd2c536c07768f8dfbe13c62
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SARWconst)
v.AddArg(x)
return true
}
- goto end0bf07ce9cd2c536c07768f8dfbe13c62
-end0bf07ce9cd2c536c07768f8dfbe13c62:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SARWconst(v *Value, config *Config) bool {
// match: (SARWconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [d>>uint64(c)])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endca23e80dba22ab574f843c7a4cef24ab
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = d >> uint64(c)
return true
}
- goto endca23e80dba22ab574f843c7a4cef24ab
-endca23e80dba22ab574f843c7a4cef24ab:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value, config *Config) bool {
// match: (SBBLcarrymask (FlagEQ))
// cond:
// result: (MOVLconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end49bb4f49864044e2cd06c9c8e2c05f12
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end49bb4f49864044e2cd06c9c8e2c05f12
-end49bb4f49864044e2cd06c9c8e2c05f12:
- ;
// match: (SBBLcarrymask (FlagLT_ULT))
// cond:
// result: (MOVLconst [-1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto ende534d42c655e8b95b051e7ec44d4fdf9
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = -1
return true
}
- goto ende534d42c655e8b95b051e7ec44d4fdf9
-ende534d42c655e8b95b051e7ec44d4fdf9:
- ;
// match: (SBBLcarrymask (FlagLT_UGT))
// cond:
// result: (MOVLconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end212628069f217f165eaf49dcfd9e8c76
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end212628069f217f165eaf49dcfd9e8c76
-end212628069f217f165eaf49dcfd9e8c76:
- ;
// match: (SBBLcarrymask (FlagGT_ULT))
// cond:
// result: (MOVLconst [-1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end4df0bf7db9772a6011ed89bd3ce95f1d
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = -1
return true
}
- goto end4df0bf7db9772a6011ed89bd3ce95f1d
-end4df0bf7db9772a6011ed89bd3ce95f1d:
- ;
// match: (SBBLcarrymask (FlagGT_UGT))
// cond:
// result: (MOVLconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end4d9d1509d6d260332f0a345332ce89e2
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end4d9d1509d6d260332f0a345332ce89e2
-end4d9d1509d6d260332f0a345332ce89e2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value, config *Config) bool {
// match: (SBBQcarrymask (FlagEQ))
// cond:
// result: (MOVQconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end6b4a6f105b53df8063846a528bab0abb
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto end6b4a6f105b53df8063846a528bab0abb
-end6b4a6f105b53df8063846a528bab0abb:
- ;
// match: (SBBQcarrymask (FlagLT_ULT))
// cond:
// result: (MOVQconst [-1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto endbfed0a1a93d6d8570f304898550d9558
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = -1
return true
}
- goto endbfed0a1a93d6d8570f304898550d9558
-endbfed0a1a93d6d8570f304898550d9558:
- ;
// match: (SBBQcarrymask (FlagLT_UGT))
// cond:
// result: (MOVQconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end8edf88458891c571a6ea6e52e0267b40
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto end8edf88458891c571a6ea6e52e0267b40
-end8edf88458891c571a6ea6e52e0267b40:
- ;
// match: (SBBQcarrymask (FlagGT_ULT))
// cond:
// result: (MOVQconst [-1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end4663340439f2fa7a666e81f0ebc68436
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = -1
return true
}
- goto end4663340439f2fa7a666e81f0ebc68436
-end4663340439f2fa7a666e81f0ebc68436:
- ;
// match: (SBBQcarrymask (FlagGT_UGT))
// cond:
// result: (MOVQconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end7262400b0380a163bd65b88e0c3db985
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto end7262400b0380a163bd65b88e0c3db985
-end7262400b0380a163bd65b88e0c3db985:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETA(v *Value, config *Config) bool {
// match: (SETA (InvertFlags x))
// cond:
// result: (SETB x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto enda4ac36e94fc279d762b5a6c7c6cc665d
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETB)
v.AddArg(x)
return true
}
- goto enda4ac36e94fc279d762b5a6c7c6cc665d
-enda4ac36e94fc279d762b5a6c7c6cc665d:
- ;
// match: (SETA (FlagEQ))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end1521942d06b7f0caba92883aee0bb90e
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end1521942d06b7f0caba92883aee0bb90e
-end1521942d06b7f0caba92883aee0bb90e:
- ;
// match: (SETA (FlagLT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto endf79d69b18a140d5c6669216ad65f60f0
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endf79d69b18a140d5c6669216ad65f60f0
-endf79d69b18a140d5c6669216ad65f60f0:
- ;
// match: (SETA (FlagLT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end272c1e5fca714e319fb1c335023826db
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end272c1e5fca714e319fb1c335023826db
-end272c1e5fca714e319fb1c335023826db:
- ;
// match: (SETA (FlagGT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto ende0cf0104de1315266d93ded9a092302c
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto ende0cf0104de1315266d93ded9a092302c
-ende0cf0104de1315266d93ded9a092302c:
- ;
// match: (SETA (FlagGT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end85507f7549319577f9994826ee379f3b
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end85507f7549319577f9994826ee379f3b
-end85507f7549319577f9994826ee379f3b:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETAE(v *Value, config *Config) bool {
// match: (SETAE (InvertFlags x))
// cond:
// result: (SETBE x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto end0468f5be6caf682fdea6b91d6648991e
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETBE)
v.AddArg(x)
return true
}
- goto end0468f5be6caf682fdea6b91d6648991e
-end0468f5be6caf682fdea6b91d6648991e:
- ;
// match: (SETAE (FlagEQ))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto endc6396df3825db703a99be0e624c6396f
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endc6396df3825db703a99be0e624c6396f
-endc6396df3825db703a99be0e624c6396f:
- ;
// match: (SETAE (FlagLT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto end2392c77d6746969c65a422c68ad193bc
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end2392c77d6746969c65a422c68ad193bc
-end2392c77d6746969c65a422c68ad193bc:
- ;
// match: (SETAE (FlagLT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end081f3b2b98d3a990739d2a5562d4f254
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end081f3b2b98d3a990739d2a5562d4f254
-end081f3b2b98d3a990739d2a5562d4f254:
- ;
// match: (SETAE (FlagGT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end47a6cc5efdd00e349c5e23be3624d719
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end47a6cc5efdd00e349c5e23be3624d719
-end47a6cc5efdd00e349c5e23be3624d719:
- ;
// match: (SETAE (FlagGT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto endd47bb51035b00c560b5347b3be19e20e
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endd47bb51035b00c560b5347b3be19e20e
-endd47bb51035b00c560b5347b3be19e20e:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETB(v *Value, config *Config) bool {
// match: (SETB (InvertFlags x))
// cond:
// result: (SETA x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto endc9eba7aa1e54a228570d2f5cc96f3565
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETA)
v.AddArg(x)
return true
}
- goto endc9eba7aa1e54a228570d2f5cc96f3565
-endc9eba7aa1e54a228570d2f5cc96f3565:
- ;
// match: (SETB (FlagEQ))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto endaf8a2c61689b00c8ad90dd090e634c81
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endaf8a2c61689b00c8ad90dd090e634c81
-endaf8a2c61689b00c8ad90dd090e634c81:
- ;
// match: (SETB (FlagLT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto endab96387d5f049ab9c87863473a5d6510
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endab96387d5f049ab9c87863473a5d6510
-endab96387d5f049ab9c87863473a5d6510:
- ;
// match: (SETB (FlagLT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto endbf7af56278add8851974cd1a538b3b7f
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endbf7af56278add8851974cd1a538b3b7f
-endbf7af56278add8851974cd1a538b3b7f:
- ;
// match: (SETB (FlagGT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end2d07a10db28e5160fccf66ee44c4823e
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end2d07a10db28e5160fccf66ee44c4823e
-end2d07a10db28e5160fccf66ee44c4823e:
- ;
// match: (SETB (FlagGT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end87ec5187683c0ee498c0a2c4de59f4c0
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end87ec5187683c0ee498c0a2c4de59f4c0
-end87ec5187683c0ee498c0a2c4de59f4c0:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETBE(v *Value, config *Config) bool {
// match: (SETBE (InvertFlags x))
// cond:
// result: (SETAE x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto end9d9031643469798b14b8cad1f5a7a1ba
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETAE)
v.AddArg(x)
return true
}
- goto end9d9031643469798b14b8cad1f5a7a1ba
-end9d9031643469798b14b8cad1f5a7a1ba:
- ;
// match: (SETBE (FlagEQ))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto ende6a02d3ce0e1584e806c7861de97eb5b
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto ende6a02d3ce0e1584e806c7861de97eb5b
-ende6a02d3ce0e1584e806c7861de97eb5b:
- ;
// match: (SETBE (FlagLT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto end7ea0208cd10e6311655d09e8aa354169
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end7ea0208cd10e6311655d09e8aa354169
-end7ea0208cd10e6311655d09e8aa354169:
- ;
// match: (SETBE (FlagLT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto enddbfa0595802c67348d3a3bd22b198231
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto enddbfa0595802c67348d3a3bd22b198231
-enddbfa0595802c67348d3a3bd22b198231:
- ;
// match: (SETBE (FlagGT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end5b26e1d28d6a517ed004b0f9b80df27b
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end5b26e1d28d6a517ed004b0f9b80df27b
-end5b26e1d28d6a517ed004b0f9b80df27b:
- ;
// match: (SETBE (FlagGT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end679e2e0ccd0dd526ea781fc64102cb88
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end679e2e0ccd0dd526ea781fc64102cb88
-end679e2e0ccd0dd526ea781fc64102cb88:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETEQ(v *Value, config *Config) bool {
// match: (SETEQ (InvertFlags x))
// cond:
// result: (SETEQ x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto end5d2039c9368d8c0cfba23b5a85b459e1
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETEQ)
v.AddArg(x)
return true
}
- goto end5d2039c9368d8c0cfba23b5a85b459e1
-end5d2039c9368d8c0cfba23b5a85b459e1:
- ;
// match: (SETEQ (FlagEQ))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end74e09087ca9d4bdf7740f4f052d2b9d3
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end74e09087ca9d4bdf7740f4f052d2b9d3
-end74e09087ca9d4bdf7740f4f052d2b9d3:
- ;
// match: (SETEQ (FlagLT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto ende5d3756d09e616648de68d364b2c308f
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto ende5d3756d09e616648de68d364b2c308f
-ende5d3756d09e616648de68d364b2c308f:
- ;
// match: (SETEQ (FlagLT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end1a86a603a5c6e0f328f63b9279137bcc
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end1a86a603a5c6e0f328f63b9279137bcc
-end1a86a603a5c6e0f328f63b9279137bcc:
- ;
// match: (SETEQ (FlagGT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto endbf907332cd6004c73b88f43b5e20275f
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endbf907332cd6004c73b88f43b5e20275f
-endbf907332cd6004c73b88f43b5e20275f:
- ;
// match: (SETEQ (FlagGT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end707540a9904307c186884f60e425ca62
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end707540a9904307c186884f60e425ca62
-end707540a9904307c186884f60e425ca62:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETG(v *Value, config *Config) bool {
// match: (SETG (InvertFlags x))
// cond:
// result: (SETL x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto endf7586738694c9cd0b74ae28bbadb649f
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETL)
v.AddArg(x)
return true
}
- goto endf7586738694c9cd0b74ae28bbadb649f
-endf7586738694c9cd0b74ae28bbadb649f:
- ;
// match: (SETG (FlagEQ))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto endc952db8883f26126822bac29276b0690
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endc952db8883f26126822bac29276b0690
-endc952db8883f26126822bac29276b0690:
- ;
// match: (SETG (FlagLT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto end3b6d659c9285d30eba022a85c6c6f1c9
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end3b6d659c9285d30eba022a85c6c6f1c9
-end3b6d659c9285d30eba022a85c6c6f1c9:
- ;
// match: (SETG (FlagLT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end2eabfc908ca06e7d5d217142dd48af33
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end2eabfc908ca06e7d5d217142dd48af33
-end2eabfc908ca06e7d5d217142dd48af33:
- ;
// match: (SETG (FlagGT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end7c059e63a98776c77bb8e43759d2d864
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end7c059e63a98776c77bb8e43759d2d864
-end7c059e63a98776c77bb8e43759d2d864:
- ;
// match: (SETG (FlagGT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto enddcb3196491c82060bcb90da722ffa8bd
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto enddcb3196491c82060bcb90da722ffa8bd
-enddcb3196491c82060bcb90da722ffa8bd:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETGE(v *Value, config *Config) bool {
// match: (SETGE (InvertFlags x))
// cond:
// result: (SETLE x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto end82c11eff6f842159f564f2dad3d2eedc
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETLE)
v.AddArg(x)
return true
}
- goto end82c11eff6f842159f564f2dad3d2eedc
-end82c11eff6f842159f564f2dad3d2eedc:
- ;
// match: (SETGE (FlagEQ))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end1152b03b15fb4ea1822b2cc1c6815887
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end1152b03b15fb4ea1822b2cc1c6815887
-end1152b03b15fb4ea1822b2cc1c6815887:
- ;
// match: (SETGE (FlagLT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto endd55763184b306cc32397b421df6fc994
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto endd55763184b306cc32397b421df6fc994
-endd55763184b306cc32397b421df6fc994:
- ;
// match: (SETGE (FlagLT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end209fbc531c4d6696b0b226c1ac016add
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end209fbc531c4d6696b0b226c1ac016add
-end209fbc531c4d6696b0b226c1ac016add:
- ;
// match: (SETGE (FlagGT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end41600cc6b5af1497fc534af49eaf60a2
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end41600cc6b5af1497fc534af49eaf60a2
-end41600cc6b5af1497fc534af49eaf60a2:
- ;
// match: (SETGE (FlagGT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto endaa33fb1204dba90a141a9a945a9643a2
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endaa33fb1204dba90a141a9a945a9643a2
-endaa33fb1204dba90a141a9a945a9643a2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETL(v *Value, config *Config) bool {
// match: (SETL (InvertFlags x))
// cond:
// result: (SETG x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto ende33160cd86b9d4d3b77e02fb4658d5d3
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETG)
v.AddArg(x)
return true
}
- goto ende33160cd86b9d4d3b77e02fb4658d5d3
-ende33160cd86b9d4d3b77e02fb4658d5d3:
- ;
// match: (SETL (FlagEQ))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end52e421ca76fa5dfba6b9bc35b220c0bf
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end52e421ca76fa5dfba6b9bc35b220c0bf
-end52e421ca76fa5dfba6b9bc35b220c0bf:
- ;
// match: (SETL (FlagLT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto end4d9781536010887bcf6f6ffd563e6aac
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end4d9781536010887bcf6f6ffd563e6aac
-end4d9781536010887bcf6f6ffd563e6aac:
- ;
// match: (SETL (FlagLT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto end9d0dd525ca800cb3ec73e94d60c3cbf1
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end9d0dd525ca800cb3ec73e94d60c3cbf1
-end9d0dd525ca800cb3ec73e94d60c3cbf1:
- ;
// match: (SETL (FlagGT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end6d77da1539ee0ebebee0e162c55e8f6e
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end6d77da1539ee0ebebee0e162c55e8f6e
-end6d77da1539ee0ebebee0e162c55e8f6e:
- ;
// match: (SETL (FlagGT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end6c129bef0cc197325a338d17720516d1
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end6c129bef0cc197325a338d17720516d1
-end6c129bef0cc197325a338d17720516d1:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETLE(v *Value, config *Config) bool {
// match: (SETLE (InvertFlags x))
// cond:
// result: (SETGE x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto end9307d96753efbeb888d1c98a6aba7a29
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETGE)
v.AddArg(x)
return true
}
- goto end9307d96753efbeb888d1c98a6aba7a29
-end9307d96753efbeb888d1c98a6aba7a29:
- ;
// match: (SETLE (FlagEQ))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end43f998d2f9524fcdf45bab9fe672aa7c
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end43f998d2f9524fcdf45bab9fe672aa7c
-end43f998d2f9524fcdf45bab9fe672aa7c:
- ;
// match: (SETLE (FlagLT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto end80212f1ca6a01bccdf4bbd5aa15d5aab
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end80212f1ca6a01bccdf4bbd5aa15d5aab
-end80212f1ca6a01bccdf4bbd5aa15d5aab:
- ;
// match: (SETLE (FlagLT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto endd5ab2a8df7344cd7c8e1092d78bfd871
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endd5ab2a8df7344cd7c8e1092d78bfd871
-endd5ab2a8df7344cd7c8e1092d78bfd871:
- ;
// match: (SETLE (FlagGT_ULT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto enda74997e85c6f82ff1c530e6051d01e21
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto enda74997e85c6f82ff1c530e6051d01e21
-enda74997e85c6f82ff1c530e6051d01e21:
- ;
// match: (SETLE (FlagGT_UGT))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end7694b41632545d10fcc6339063c53f07
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end7694b41632545d10fcc6339063c53f07
-end7694b41632545d10fcc6339063c53f07:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SETNE(v *Value, config *Config) bool {
// match: (SETNE (InvertFlags x))
// cond:
// result: (SETNE x)
- {
+ for {
if v.Args[0].Op != OpAMD64InvertFlags {
- goto endbc71811b789475308014550f638026eb
+ break
}
x := v.Args[0].Args[0]
v.reset(OpAMD64SETNE)
v.AddArg(x)
return true
}
- goto endbc71811b789475308014550f638026eb
-endbc71811b789475308014550f638026eb:
- ;
// match: (SETNE (FlagEQ))
// cond:
// result: (MOVBconst [0])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagEQ {
- goto end6b66ea2ed518a926a071fe0d3dce46d8
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end6b66ea2ed518a926a071fe0d3dce46d8
-end6b66ea2ed518a926a071fe0d3dce46d8:
- ;
// match: (SETNE (FlagLT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_ULT {
- goto ende4d3b99f9dff014be3067a577ba0b016
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto ende4d3b99f9dff014be3067a577ba0b016
-ende4d3b99f9dff014be3067a577ba0b016:
- ;
// match: (SETNE (FlagLT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagLT_UGT {
- goto endb98d73ed6e5d3d21c2ea33840ab2a21c
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto endb98d73ed6e5d3d21c2ea33840ab2a21c
-endb98d73ed6e5d3d21c2ea33840ab2a21c:
- ;
// match: (SETNE (FlagGT_ULT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_ULT {
- goto end3bceb5cece8d0112cc8cd53435d64ef4
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end3bceb5cece8d0112cc8cd53435d64ef4
-end3bceb5cece8d0112cc8cd53435d64ef4:
- ;
// match: (SETNE (FlagGT_UGT))
// cond:
// result: (MOVBconst [1])
- {
+ for {
if v.Args[0].Op != OpAMD64FlagGT_UGT {
- goto end9249b3ed3e1e582dd5435fb73cbc13ac
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 1
return true
}
- goto end9249b3ed3e1e582dd5435fb73cbc13ac
-end9249b3ed3e1e582dd5435fb73cbc13ac:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHLB(v *Value, config *Config) bool {
// match: (SHLB x (MOVQconst [c]))
// cond:
// result: (SHLBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto endb1f377b81b6f4c1864893934230ecbd1
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLBconst)
v.AddArg(x)
return true
}
- goto endb1f377b81b6f4c1864893934230ecbd1
-endb1f377b81b6f4c1864893934230ecbd1:
- ;
// match: (SHLB x (MOVLconst [c]))
// cond:
// result: (SHLBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end434bc4ee26d93bf1c734be760d7a1aa6
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLBconst)
v.AddArg(x)
return true
}
- goto end434bc4ee26d93bf1c734be760d7a1aa6
-end434bc4ee26d93bf1c734be760d7a1aa6:
- ;
// match: (SHLB x (MOVWconst [c]))
// cond:
// result: (SHLBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLBconst)
v.AddArg(x)
return true
}
- goto end2c4fe4cce2ae24e0bc5c7d209d22e9d9
-end2c4fe4cce2ae24e0bc5c7d209d22e9d9:
- ;
// match: (SHLB x (MOVBconst [c]))
// cond:
// result: (SHLBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end2d0d0111d831d8a575b5627284a6337a
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLBconst)
v.AddArg(x)
return true
}
- goto end2d0d0111d831d8a575b5627284a6337a
-end2d0d0111d831d8a575b5627284a6337a:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHLL(v *Value, config *Config) bool {
// match: (SHLL x (MOVQconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end1b4f8b8d62445fdcb3cf9cd5036b559b
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLLconst)
v.AddArg(x)
return true
}
- goto end1b4f8b8d62445fdcb3cf9cd5036b559b
-end1b4f8b8d62445fdcb3cf9cd5036b559b:
- ;
// match: (SHLL x (MOVLconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end633f9ddcfbb63374c895a5f78da75d25
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLLconst)
v.AddArg(x)
return true
}
- goto end633f9ddcfbb63374c895a5f78da75d25
-end633f9ddcfbb63374c895a5f78da75d25:
- ;
// match: (SHLL x (MOVWconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto enda4f59495061db6cfe796b6dba8d3cad8
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLLconst)
v.AddArg(x)
return true
}
- goto enda4f59495061db6cfe796b6dba8d3cad8
-enda4f59495061db6cfe796b6dba8d3cad8:
- ;
// match: (SHLL x (MOVBconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endd6f39b5f3174ca738ae1c48a96d837a6
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLLconst)
v.AddArg(x)
return true
}
- goto endd6f39b5f3174ca738ae1c48a96d837a6
-endd6f39b5f3174ca738ae1c48a96d837a6:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHLQ(v *Value, config *Config) bool {
// match: (SHLQ x (MOVQconst [c]))
// cond:
// result: (SHLQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end4d7e3a945cacdd6b6c8c0de6f465d4ae
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLQconst)
v.AddArg(x)
return true
}
- goto end4d7e3a945cacdd6b6c8c0de6f465d4ae
-end4d7e3a945cacdd6b6c8c0de6f465d4ae:
- ;
// match: (SHLQ x (MOVLconst [c]))
// cond:
// result: (SHLQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end394bae2652a3e4bc4b70a6fc193949f8
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLQconst)
v.AddArg(x)
return true
}
- goto end394bae2652a3e4bc4b70a6fc193949f8
-end394bae2652a3e4bc4b70a6fc193949f8:
- ;
// match: (SHLQ x (MOVWconst [c]))
// cond:
// result: (SHLQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end358be4078efa15ceb443ccda7ce592a0
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLQconst)
v.AddArg(x)
return true
}
- goto end358be4078efa15ceb443ccda7ce592a0
-end358be4078efa15ceb443ccda7ce592a0:
- ;
// match: (SHLQ x (MOVBconst [c]))
// cond:
// result: (SHLQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end032e0efd085f37a12322dbc63795a1b2
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLQconst)
v.AddArg(x)
return true
}
- goto end032e0efd085f37a12322dbc63795a1b2
-end032e0efd085f37a12322dbc63795a1b2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHLW(v *Value, config *Config) bool {
// match: (SHLW x (MOVQconst [c]))
// cond:
// result: (SHLWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto enda29aa85ce58b1fdb63d71e2632efd6db
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLWconst)
v.AddArg(x)
return true
}
- goto enda29aa85ce58b1fdb63d71e2632efd6db
-enda29aa85ce58b1fdb63d71e2632efd6db:
- ;
// match: (SHLW x (MOVLconst [c]))
// cond:
// result: (SHLWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end59ce264ffde0ef9af8ea1a25db7173b6
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLWconst)
v.AddArg(x)
return true
}
- goto end59ce264ffde0ef9af8ea1a25db7173b6
-end59ce264ffde0ef9af8ea1a25db7173b6:
- ;
// match: (SHLW x (MOVWconst [c]))
// cond:
// result: (SHLWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto endba96a52aa58d28b3357828051e0e695c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLWconst)
v.AddArg(x)
return true
}
- goto endba96a52aa58d28b3357828051e0e695c
-endba96a52aa58d28b3357828051e0e695c:
- ;
// match: (SHLW x (MOVBconst [c]))
// cond:
// result: (SHLWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endf9c2165ea24ac7bbdd46cdf0e084104f
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHLWconst)
v.AddArg(x)
return true
}
- goto endf9c2165ea24ac7bbdd46cdf0e084104f
-endf9c2165ea24ac7bbdd46cdf0e084104f:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHRB(v *Value, config *Config) bool {
// match: (SHRB x (MOVQconst [c]))
// cond:
// result: (SHRBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end2e7fb7a5406cbf51c69a0d04dc73d16a
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRBconst)
v.AddArg(x)
return true
}
- goto end2e7fb7a5406cbf51c69a0d04dc73d16a
-end2e7fb7a5406cbf51c69a0d04dc73d16a:
- ;
// match: (SHRB x (MOVLconst [c]))
// cond:
// result: (SHRBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end69603cc51e4f244388f368dd188a526a
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRBconst)
v.AddArg(x)
return true
}
- goto end69603cc51e4f244388f368dd188a526a
-end69603cc51e4f244388f368dd188a526a:
- ;
// match: (SHRB x (MOVWconst [c]))
// cond:
// result: (SHRBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto endd96421647299a1bb1b68ad0a90fa0be3
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRBconst)
v.AddArg(x)
return true
}
- goto endd96421647299a1bb1b68ad0a90fa0be3
-endd96421647299a1bb1b68ad0a90fa0be3:
- ;
// match: (SHRB x (MOVBconst [c]))
// cond:
// result: (SHRBconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto enddb1cd5aaa826d43fa4f6d1b2b8795e58
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRBconst)
v.AddArg(x)
return true
}
- goto enddb1cd5aaa826d43fa4f6d1b2b8795e58
-enddb1cd5aaa826d43fa4f6d1b2b8795e58:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHRL(v *Value, config *Config) bool {
// match: (SHRL x (MOVQconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end893880cdc59697295c1849a250163e59
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRLconst)
v.AddArg(x)
return true
}
- goto end893880cdc59697295c1849a250163e59
-end893880cdc59697295c1849a250163e59:
- ;
// match: (SHRL x (MOVLconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end344b8b9202e1925e8d0561f1c21412fc
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRLconst)
v.AddArg(x)
return true
}
- goto end344b8b9202e1925e8d0561f1c21412fc
-end344b8b9202e1925e8d0561f1c21412fc:
- ;
// match: (SHRL x (MOVWconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end561280f746f9983f4a4b4a5119b53028
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRLconst)
v.AddArg(x)
return true
}
- goto end561280f746f9983f4a4b4a5119b53028
-end561280f746f9983f4a4b4a5119b53028:
- ;
// match: (SHRL x (MOVBconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto enda339271c59d274b73c04ba1f2c44c2b9
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRLconst)
v.AddArg(x)
return true
}
- goto enda339271c59d274b73c04ba1f2c44c2b9
-enda339271c59d274b73c04ba1f2c44c2b9:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHRQ(v *Value, config *Config) bool {
// match: (SHRQ x (MOVQconst [c]))
// cond:
// result: (SHRQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end699d35e2d5cfa08b8a3b1c8a183ddcf3
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRQconst)
v.AddArg(x)
return true
}
- goto end699d35e2d5cfa08b8a3b1c8a183ddcf3
-end699d35e2d5cfa08b8a3b1c8a183ddcf3:
- ;
// match: (SHRQ x (MOVLconst [c]))
// cond:
// result: (SHRQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end3189f4abaac8028d9191c9ba64124999
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRQconst)
v.AddArg(x)
return true
}
- goto end3189f4abaac8028d9191c9ba64124999
-end3189f4abaac8028d9191c9ba64124999:
- ;
// match: (SHRQ x (MOVWconst [c]))
// cond:
// result: (SHRQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end0cbc86ae04a355c0e2a96400242f4633
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRQconst)
v.AddArg(x)
return true
}
- goto end0cbc86ae04a355c0e2a96400242f4633
-end0cbc86ae04a355c0e2a96400242f4633:
- ;
// match: (SHRQ x (MOVBconst [c]))
// cond:
// result: (SHRQconst [c&63] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto endb9c003612674e7a1ea7c13e463c229d2
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRQconst)
v.AddArg(x)
return true
}
- goto endb9c003612674e7a1ea7c13e463c229d2
-endb9c003612674e7a1ea7c13e463c229d2:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SHRW(v *Value, config *Config) bool {
// match: (SHRW x (MOVQconst [c]))
// cond:
// result: (SHRWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto endc5c82eea9a6b51b1d6b76e57f21f46ff
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRWconst)
v.AddArg(x)
return true
}
- goto endc5c82eea9a6b51b1d6b76e57f21f46ff
-endc5c82eea9a6b51b1d6b76e57f21f46ff:
- ;
// match: (SHRW x (MOVLconst [c]))
// cond:
// result: (SHRWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end773e94c857256ae9a31eb5b3d667e64b
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRWconst)
v.AddArg(x)
return true
}
- goto end773e94c857256ae9a31eb5b3d667e64b
-end773e94c857256ae9a31eb5b3d667e64b:
- ;
// match: (SHRW x (MOVWconst [c]))
// cond:
// result: (SHRWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto endd75ff1f9b3e9ec9c942a39b6179da1b3
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRWconst)
v.AddArg(x)
return true
}
- goto endd75ff1f9b3e9ec9c942a39b6179da1b3
-endd75ff1f9b3e9ec9c942a39b6179da1b3:
- ;
// match: (SHRW x (MOVBconst [c]))
// cond:
// result: (SHRWconst [c&31] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end6761530cd742ad00057c19a6a3c38ada
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SHRWconst)
v.AddArg(x)
return true
}
- goto end6761530cd742ad00057c19a6a3c38ada
-end6761530cd742ad00057c19a6a3c38ada:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBB(v *Value, config *Config) bool {
// match: (SUBB x (MOVBconst [c]))
// cond:
// result: (SUBBconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SUBBconst)
v.AuxInt = c
return true
}
- goto end9ca5d2a70e2df1a5a3ed6786bce1f7b2
-end9ca5d2a70e2df1a5a3ed6786bce1f7b2:
- ;
// match: (SUBB (MOVBconst [c]) x)
// cond:
// result: (NEGB (SUBBconst <v.Type> x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endc288755d69b04d24a6aac32a73956411
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto endc288755d69b04d24a6aac32a73956411
-endc288755d69b04d24a6aac32a73956411:
- ;
// match: (SUBB x x)
// cond:
// result: (MOVBconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto ende8904403d937d95b0d6133d3ec92bb45
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto ende8904403d937d95b0d6133d3ec92bb45
-ende8904403d937d95b0d6133d3ec92bb45:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBBconst(v *Value, config *Config) bool {
// match: (SUBBconst [c] x)
// cond: int8(c) == 0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int8(c) == 0) {
- goto end974a26e947badc62fc104581f49138e6
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end974a26e947badc62fc104581f49138e6
-end974a26e947badc62fc104581f49138e6:
- ;
// match: (SUBBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [d-c])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto enddc5383558e2f3eae507afcb94eada964
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = d - c
return true
}
- goto enddc5383558e2f3eae507afcb94eada964
-enddc5383558e2f3eae507afcb94eada964:
- ;
// match: (SUBBconst [c] (SUBBconst [d] x))
// cond:
// result: (ADDBconst [-c-d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64SUBBconst {
- goto end035c57413a46eb347ecb3736d1510915
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end035c57413a46eb347ecb3736d1510915
-end035c57413a46eb347ecb3736d1510915:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBL(v *Value, config *Config) bool {
// match: (SUBL x (MOVLconst [c]))
// cond:
// result: (SUBLconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto end178c1d6c86f9c16f6497586c2f7d8625
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SUBLconst)
v.AuxInt = c
return true
}
- goto end178c1d6c86f9c16f6497586c2f7d8625
-end178c1d6c86f9c16f6497586c2f7d8625:
- ;
// match: (SUBL (MOVLconst [c]) x)
// cond:
// result: (NEGL (SUBLconst <v.Type> x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto endb0efe6e15ec20486b849534a00483ae2
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto endb0efe6e15ec20486b849534a00483ae2
-endb0efe6e15ec20486b849534a00483ae2:
- ;
// match: (SUBL x x)
// cond:
// result: (MOVLconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end332f1f641f875c69bea7289191e69133
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end332f1f641f875c69bea7289191e69133
-end332f1f641f875c69bea7289191e69133:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBLconst(v *Value, config *Config) bool {
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int32(c) == 0) {
- goto end3fa10eaa42f9e283cf1757e1b2d3cac2
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end3fa10eaa42f9e283cf1757e1b2d3cac2
-end3fa10eaa42f9e283cf1757e1b2d3cac2:
- ;
// match: (SUBLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [d-c])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = d - c
return true
}
- goto end6c5c6d58d4bdd0a5c2f7bf10b343b41e
-end6c5c6d58d4bdd0a5c2f7bf10b343b41e:
- ;
// match: (SUBLconst [c] (SUBLconst [d] x))
// cond:
// result: (ADDLconst [-c-d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64SUBLconst {
- goto end0c9ffb11e8a56ced1b14dbf6bf9a6737
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end0c9ffb11e8a56ced1b14dbf6bf9a6737
-end0c9ffb11e8a56ced1b14dbf6bf9a6737:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBQ(v *Value, config *Config) bool {
// match: (SUBQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (SUBQconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end9bbb7b20824a498752c605942fad89c2
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end9bbb7b20824a498752c605942fad89c2
+ break
}
v.reset(OpAMD64SUBQconst)
v.AddArg(x)
v.AuxInt = c
return true
}
- goto end9bbb7b20824a498752c605942fad89c2
-end9bbb7b20824a498752c605942fad89c2:
- ;
// match: (SUBQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (NEGQ (SUBQconst <v.Type> x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end8beb96de3efee9206d1bd4b7d777d2cb
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto end8beb96de3efee9206d1bd4b7d777d2cb
+ break
}
v.reset(OpAMD64NEGQ)
v0 := b.NewValue0(v.Line, OpAMD64SUBQconst, v.Type)
v.AddArg(v0)
return true
}
- goto end8beb96de3efee9206d1bd4b7d777d2cb
-end8beb96de3efee9206d1bd4b7d777d2cb:
- ;
// match: (SUBQ x x)
// cond:
// result: (MOVQconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endd87d1d839d2dc54d9c90fa4f73383480
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto endd87d1d839d2dc54d9c90fa4f73383480
-endd87d1d839d2dc54d9c90fa4f73383480:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBQconst(v *Value, config *Config) bool {
// match: (SUBQconst [0] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto endfce1d3cec7c543c9dd80a27d944eb09e
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto endfce1d3cec7c543c9dd80a27d944eb09e
-endfce1d3cec7c543c9dd80a27d944eb09e:
- ;
// match: (SUBQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [d-c])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endb0daebe6831cf381377c3e4248070f25
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = d - c
return true
}
- goto endb0daebe6831cf381377c3e4248070f25
-endb0daebe6831cf381377c3e4248070f25:
- ;
// match: (SUBQconst [c] (SUBQconst [d] x))
// cond:
// result: (ADDQconst [-c-d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64SUBQconst {
- goto end2d40ddb5ae9e90679456254c61858d9d
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto end2d40ddb5ae9e90679456254c61858d9d
-end2d40ddb5ae9e90679456254c61858d9d:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBW(v *Value, config *Config) bool {
// match: (SUBW x (MOVWconst [c]))
// cond:
// result: (SUBWconst x [c])
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end135aa9100b2f61d58b37cede37b63731
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64SUBWconst)
v.AuxInt = c
return true
}
- goto end135aa9100b2f61d58b37cede37b63731
-end135aa9100b2f61d58b37cede37b63731:
- ;
// match: (SUBW (MOVWconst [c]) x)
// cond:
// result: (NEGW (SUBWconst <v.Type> x [c]))
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end44d23f7e65a4b1c42d0e6463f8e493b6
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(v0)
return true
}
- goto end44d23f7e65a4b1c42d0e6463f8e493b6
-end44d23f7e65a4b1c42d0e6463f8e493b6:
- ;
// match: (SUBW x x)
// cond:
// result: (MOVWconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endb970e7c318d04a1afe1dfe08a7ca0d9c
+ break
}
v.reset(OpAMD64MOVWconst)
v.AuxInt = 0
return true
}
- goto endb970e7c318d04a1afe1dfe08a7ca0d9c
-endb970e7c318d04a1afe1dfe08a7ca0d9c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64SUBWconst(v *Value, config *Config) bool {
// match: (SUBWconst [c] x)
// cond: int16(c) == 0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int16(c) == 0) {
- goto end1e7a493992465c9cc8314e3256ed6394
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end1e7a493992465c9cc8314e3256ed6394
-end1e7a493992465c9cc8314e3256ed6394:
- ;
// match: (SUBWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [d-c])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto endae629a229c399eaed7dbb95b1b0e6f8a
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = d - c
return true
}
- goto endae629a229c399eaed7dbb95b1b0e6f8a
-endae629a229c399eaed7dbb95b1b0e6f8a:
- ;
// match: (SUBWconst [c] (SUBWconst [d] x))
// cond:
// result: (ADDWconst [-c-d] x)
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64SUBWconst {
- goto enda59f08d12aa08717b0443b7bb1b71374
+ break
}
d := v.Args[0].AuxInt
x := v.Args[0].Args[0]
v.AddArg(x)
return true
}
- goto enda59f08d12aa08717b0443b7bb1b71374
-enda59f08d12aa08717b0443b7bb1b71374:
- ;
return false
}
func rewriteValueAMD64_OpSignExt16to32(v *Value, config *Config) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVWQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVWQSX)
v.AddArg(x)
return true
}
- goto end21e4271c2b48a5aa3561ccfa8fa67cd9
-end21e4271c2b48a5aa3561ccfa8fa67cd9:
- ;
return false
}
func rewriteValueAMD64_OpSignExt16to64(v *Value, config *Config) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVWQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVWQSX)
v.AddArg(x)
return true
}
- goto endc6d242ee3a3e195ef0f9e8dae47ada75
-endc6d242ee3a3e195ef0f9e8dae47ada75:
- ;
return false
}
func rewriteValueAMD64_OpSignExt32to64(v *Value, config *Config) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVLQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVLQSX)
v.AddArg(x)
return true
}
- goto endb9f1a8b2d01eee44964a71a01bca165c
-endb9f1a8b2d01eee44964a71a01bca165c:
- ;
return false
}
func rewriteValueAMD64_OpSignExt8to16(v *Value, config *Config) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQSX)
v.AddArg(x)
return true
}
- goto end372869f08e147404b80634e5f83fd506
-end372869f08e147404b80634e5f83fd506:
- ;
return false
}
func rewriteValueAMD64_OpSignExt8to32(v *Value, config *Config) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQSX)
v.AddArg(x)
return true
}
- goto end913e3575e5b4cf7f60585c108db40464
-end913e3575e5b4cf7f60585c108db40464:
- ;
return false
}
func rewriteValueAMD64_OpSignExt8to64(v *Value, config *Config) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBQSX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQSX)
v.AddArg(x)
return true
}
- goto endcef6d6001d3f25cf5dacee11a46e5c8c
-endcef6d6001d3f25cf5dacee11a46e5c8c:
- ;
return false
}
func rewriteValueAMD64_OpSqrt(v *Value, config *Config) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTSD x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64SQRTSD)
v.AddArg(x)
return true
}
- goto end72f79ca9ec139e15856aaa03338cf543
-end72f79ca9ec139e15856aaa03338cf543:
- ;
return false
}
func rewriteValueAMD64_OpStaticCall(v *Value, config *Config) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
- {
+ for {
argwid := v.AuxInt
target := v.Aux
mem := v.Args[0]
v.AddArg(mem)
return true
}
- goto end32c5cbec813d1c2ae94fc9b1090e4b2a
-end32c5cbec813d1c2ae94fc9b1090e4b2a:
- ;
return false
}
func rewriteValueAMD64_OpStore(v *Value, config *Config) bool {
// match: (Store [8] ptr val mem)
// cond: is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
- {
+ for {
if v.AuxInt != 8 {
- goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e
+ break
}
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
if !(is64BitFloat(val.Type)) {
- goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e
+ break
}
v.reset(OpAMD64MOVSDstore)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto endaeec4f61bc8e67dbf3fa2f79fe4c2b9e
-endaeec4f61bc8e67dbf3fa2f79fe4c2b9e:
- ;
// match: (Store [4] ptr val mem)
// cond: is32BitFloat(val.Type)
// result: (MOVSSstore ptr val mem)
- {
+ for {
if v.AuxInt != 4 {
- goto endf638ca0a75871b5062da15324d0e0384
+ break
}
ptr := v.Args[0]
val := v.Args[1]
mem := v.Args[2]
if !(is32BitFloat(val.Type)) {
- goto endf638ca0a75871b5062da15324d0e0384
+ break
}
v.reset(OpAMD64MOVSSstore)
v.AddArg(ptr)
v.AddArg(mem)
return true
}
- goto endf638ca0a75871b5062da15324d0e0384
-endf638ca0a75871b5062da15324d0e0384:
- ;
// match: (Store [8] ptr val mem)
// cond:
// result: (MOVQstore ptr val mem)
- {
+ for {
if v.AuxInt != 8 {
- goto endd1eb7c3ea0c806e7a53ff3be86186eb7
+ break
}
ptr := v.Args[0]
val := v.Args[1]
v.AddArg(mem)
return true
}
- goto endd1eb7c3ea0c806e7a53ff3be86186eb7
-endd1eb7c3ea0c806e7a53ff3be86186eb7:
- ;
// match: (Store [4] ptr val mem)
// cond:
// result: (MOVLstore ptr val mem)
- {
+ for {
if v.AuxInt != 4 {
- goto end44e3b22360da76ecd59be9a8c2dd1347
+ break
}
ptr := v.Args[0]
val := v.Args[1]
v.AddArg(mem)
return true
}
- goto end44e3b22360da76ecd59be9a8c2dd1347
-end44e3b22360da76ecd59be9a8c2dd1347:
- ;
// match: (Store [2] ptr val mem)
// cond:
// result: (MOVWstore ptr val mem)
- {
+ for {
if v.AuxInt != 2 {
- goto endd0342b7fd3d0713f3e26922660047c71
+ break
}
ptr := v.Args[0]
val := v.Args[1]
v.AddArg(mem)
return true
}
- goto endd0342b7fd3d0713f3e26922660047c71
-endd0342b7fd3d0713f3e26922660047c71:
- ;
// match: (Store [1] ptr val mem)
// cond:
// result: (MOVBstore ptr val mem)
- {
+ for {
if v.AuxInt != 1 {
- goto end8e76e20031197ca875889d2b4d0eb1d1
+ break
}
ptr := v.Args[0]
val := v.Args[1]
v.AddArg(mem)
return true
}
- goto end8e76e20031197ca875889d2b4d0eb1d1
-end8e76e20031197ca875889d2b4d0eb1d1:
- ;
return false
}
func rewriteValueAMD64_OpSub16(v *Value, config *Config) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBW)
v.AddArg(y)
return true
}
- goto end54adc5de883c0460ca71c6ee464d4244
-end54adc5de883c0460ca71c6ee464d4244:
- ;
return false
}
func rewriteValueAMD64_OpSub32(v *Value, config *Config) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBL)
v.AddArg(y)
return true
}
- goto enddc3a2a488bda8c5856f93343e5ffe5f8
-enddc3a2a488bda8c5856f93343e5ffe5f8:
- ;
return false
}
func rewriteValueAMD64_OpSub32F(v *Value, config *Config) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBSS x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBSS)
v.AddArg(y)
return true
}
- goto end20193c1804b0e707702a884fb8abd60d
-end20193c1804b0e707702a884fb8abd60d:
- ;
return false
}
func rewriteValueAMD64_OpSub64(v *Value, config *Config) bool {
// match: (Sub64 x y)
// cond:
// result: (SUBQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBQ)
v.AddArg(y)
return true
}
- goto endd88d5646309fd9174584888ecc8aca2c
-endd88d5646309fd9174584888ecc8aca2c:
- ;
return false
}
func rewriteValueAMD64_OpSub64F(v *Value, config *Config) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBSD x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBSD)
v.AddArg(y)
return true
}
- goto end5d5af7b8a3326bf9151f00a0013b73d7
-end5d5af7b8a3326bf9151f00a0013b73d7:
- ;
return false
}
func rewriteValueAMD64_OpSub8(v *Value, config *Config) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBB)
v.AddArg(y)
return true
}
- goto end7d33bf9bdfa505f96b930563eca7955f
-end7d33bf9bdfa505f96b930563eca7955f:
- ;
return false
}
func rewriteValueAMD64_OpSubPtr(v *Value, config *Config) bool {
// match: (SubPtr x y)
// cond:
// result: (SUBQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64SUBQ)
v.AddArg(y)
return true
}
- goto end748f63f755afe0b97a8f3cf7e4d9cbfe
-end748f63f755afe0b97a8f3cf7e4d9cbfe:
- ;
return false
}
func rewriteValueAMD64_OpTrunc16to8(v *Value, config *Config) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end8e2f5e0a6e3a06423c077747de6c2bdd
-end8e2f5e0a6e3a06423c077747de6c2bdd:
- ;
return false
}
func rewriteValueAMD64_OpTrunc32to16(v *Value, config *Config) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end5bed0e3a3c1c6374d86beb5a4397708c
-end5bed0e3a3c1c6374d86beb5a4397708c:
- ;
return false
}
func rewriteValueAMD64_OpTrunc32to8(v *Value, config *Config) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endef0b8032ce91979ce6cd0004260c04ee
-endef0b8032ce91979ce6cd0004260c04ee:
- ;
return false
}
func rewriteValueAMD64_OpTrunc64to16(v *Value, config *Config) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endd32fd6e0ce970c212835e6f71c3dcbfd
-endd32fd6e0ce970c212835e6f71c3dcbfd:
- ;
return false
}
func rewriteValueAMD64_OpTrunc64to32(v *Value, config *Config) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end1212c4e84153210aff7fd630fb3e1883
-end1212c4e84153210aff7fd630fb3e1883:
- ;
return false
}
func rewriteValueAMD64_OpTrunc64to8(v *Value, config *Config) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end734f017d4b2810ca2288f7037365824c
-end734f017d4b2810ca2288f7037365824c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORB(v *Value, config *Config) bool {
// match: (XORB x (MOVBconst [c]))
// cond:
// result: (XORBconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVBconst {
- goto enda9ed9fdd115ffdffa8127c007c34d7b7
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64XORBconst)
v.AddArg(x)
return true
}
- goto enda9ed9fdd115ffdffa8127c007c34d7b7
-enda9ed9fdd115ffdffa8127c007c34d7b7:
- ;
// match: (XORB (MOVBconst [c]) x)
// cond:
// result: (XORBconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVBconst {
- goto endb02a07d9dc7b802c59f013116e952f3f
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto endb02a07d9dc7b802c59f013116e952f3f
-endb02a07d9dc7b802c59f013116e952f3f:
- ;
// match: (XORB x x)
// cond:
// result: (MOVBconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end2afddc39503d04d572a3a07878f6c9c9
+ break
}
v.reset(OpAMD64MOVBconst)
v.AuxInt = 0
return true
}
- goto end2afddc39503d04d572a3a07878f6c9c9
-end2afddc39503d04d572a3a07878f6c9c9:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORBconst(v *Value, config *Config) bool {
// match: (XORBconst [c] x)
// cond: int8(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int8(c) == 0) {
- goto end14b03b70e5579dfe3f9b243e02a887c3
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end14b03b70e5579dfe3f9b243e02a887c3
-end14b03b70e5579dfe3f9b243e02a887c3:
- ;
// match: (XORBconst [c] (MOVBconst [d]))
// cond:
// result: (MOVBconst [c^d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVBconst {
- goto end6d8d1b612af9d253605c8bc69b822903
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVBconst)
v.AuxInt = c ^ d
return true
}
- goto end6d8d1b612af9d253605c8bc69b822903
-end6d8d1b612af9d253605c8bc69b822903:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORL(v *Value, config *Config) bool {
// match: (XORL x (MOVLconst [c]))
// cond:
// result: (XORLconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVLconst {
- goto enda9459d509d3416da67d13a22dd074a9c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64XORLconst)
v.AddArg(x)
return true
}
- goto enda9459d509d3416da67d13a22dd074a9c
-enda9459d509d3416da67d13a22dd074a9c:
- ;
// match: (XORL (MOVLconst [c]) x)
// cond:
// result: (XORLconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end9c1a0af00eeadd8aa325e55f1f3fb89c
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end9c1a0af00eeadd8aa325e55f1f3fb89c
-end9c1a0af00eeadd8aa325e55f1f3fb89c:
- ;
// match: (XORL x x)
// cond:
// result: (MOVLconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end7bcf9cfeb69a0d7647389124eb53ce2a
+ break
}
v.reset(OpAMD64MOVLconst)
v.AuxInt = 0
return true
}
- goto end7bcf9cfeb69a0d7647389124eb53ce2a
-end7bcf9cfeb69a0d7647389124eb53ce2a:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORLconst(v *Value, config *Config) bool {
// match: (XORLconst [c] x)
// cond: int32(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int32(c) == 0) {
- goto end99808ca9fb8e3220e42f5678e1042a08
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end99808ca9fb8e3220e42f5678e1042a08
-end99808ca9fb8e3220e42f5678e1042a08:
- ;
// match: (XORLconst [c] (MOVLconst [d]))
// cond:
// result: (MOVLconst [c^d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVLconst {
- goto end71238075b10b68a226903cc453c4715c
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVLconst)
v.AuxInt = c ^ d
return true
}
- goto end71238075b10b68a226903cc453c4715c
-end71238075b10b68a226903cc453c4715c:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORQ(v *Value, config *Config) bool {
// match: (XORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (XORQconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVQconst {
- goto end452341f950062e0483f16438fb9ec500
+ break
}
c := v.Args[1].AuxInt
if !(is32Bit(c)) {
- goto end452341f950062e0483f16438fb9ec500
+ break
}
v.reset(OpAMD64XORQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto end452341f950062e0483f16438fb9ec500
-end452341f950062e0483f16438fb9ec500:
- ;
// match: (XORQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (XORQconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVQconst {
- goto endd221a7e3daaaaa29ee385ad36e061b57
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
if !(is32Bit(c)) {
- goto endd221a7e3daaaaa29ee385ad36e061b57
+ break
}
v.reset(OpAMD64XORQconst)
v.AuxInt = c
v.AddArg(x)
return true
}
- goto endd221a7e3daaaaa29ee385ad36e061b57
-endd221a7e3daaaaa29ee385ad36e061b57:
- ;
// match: (XORQ x x)
// cond:
// result: (MOVQconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end10575a5d711cf14e6d4dffbb0e8dfaeb
+ break
}
v.reset(OpAMD64MOVQconst)
v.AuxInt = 0
return true
}
- goto end10575a5d711cf14e6d4dffbb0e8dfaeb
-end10575a5d711cf14e6d4dffbb0e8dfaeb:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORQconst(v *Value, config *Config) bool {
// match: (XORQconst [0] x)
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto end0ee8d195a97eff476cf1f69a4dc0ec75
+ break
}
x := v.Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end0ee8d195a97eff476cf1f69a4dc0ec75
-end0ee8d195a97eff476cf1f69a4dc0ec75:
- ;
// match: (XORQconst [c] (MOVQconst [d]))
// cond:
// result: (MOVQconst [c^d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVQconst {
- goto end3f404d4f07362319fbad2e1ba0827a9f
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVQconst)
v.AuxInt = c ^ d
return true
}
- goto end3f404d4f07362319fbad2e1ba0827a9f
-end3f404d4f07362319fbad2e1ba0827a9f:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORW(v *Value, config *Config) bool {
// match: (XORW x (MOVWconst [c]))
// cond:
// result: (XORWconst [c] x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpAMD64MOVWconst {
- goto end2ca109efd66c221a5691a4da95ec6c67
+ break
}
c := v.Args[1].AuxInt
v.reset(OpAMD64XORWconst)
v.AddArg(x)
return true
}
- goto end2ca109efd66c221a5691a4da95ec6c67
-end2ca109efd66c221a5691a4da95ec6c67:
- ;
// match: (XORW (MOVWconst [c]) x)
// cond:
// result: (XORWconst [c] x)
- {
+ for {
if v.Args[0].Op != OpAMD64MOVWconst {
- goto end51ee62a06d4301e5a4aed7a6639b1d53
+ break
}
c := v.Args[0].AuxInt
x := v.Args[1]
v.AddArg(x)
return true
}
- goto end51ee62a06d4301e5a4aed7a6639b1d53
-end51ee62a06d4301e5a4aed7a6639b1d53:
- ;
// match: (XORW x x)
// cond:
// result: (MOVWconst [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end07f332e857be0c2707797ed480a2faf4
+ break
}
v.reset(OpAMD64MOVWconst)
v.AuxInt = 0
return true
}
- goto end07f332e857be0c2707797ed480a2faf4
-end07f332e857be0c2707797ed480a2faf4:
- ;
return false
}
func rewriteValueAMD64_OpAMD64XORWconst(v *Value, config *Config) bool {
// match: (XORWconst [c] x)
// cond: int16(c)==0
// result: x
- {
+ for {
c := v.AuxInt
x := v.Args[0]
if !(int16(c) == 0) {
- goto enda371132353dee83828836da851240f0a
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto enda371132353dee83828836da851240f0a
-enda371132353dee83828836da851240f0a:
- ;
// match: (XORWconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [c^d])
- {
+ for {
c := v.AuxInt
if v.Args[0].Op != OpAMD64MOVWconst {
- goto ende24881ccdfa8486c4593fd9aa5df1ed6
+ break
}
d := v.Args[0].AuxInt
v.reset(OpAMD64MOVWconst)
v.AuxInt = c ^ d
return true
}
- goto ende24881ccdfa8486c4593fd9aa5df1ed6
-ende24881ccdfa8486c4593fd9aa5df1ed6:
- ;
return false
}
func rewriteValueAMD64_OpXor16(v *Value, config *Config) bool {
// match: (Xor16 x y)
// cond:
// result: (XORW x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64XORW)
v.AddArg(y)
return true
}
- goto end20efdd5dfd5130abf818de5546a991a0
-end20efdd5dfd5130abf818de5546a991a0:
- ;
return false
}
func rewriteValueAMD64_OpXor32(v *Value, config *Config) bool {
// match: (Xor32 x y)
// cond:
// result: (XORL x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64XORL)
v.AddArg(y)
return true
}
- goto end9da6bce98b437e2609488346116a75d8
-end9da6bce98b437e2609488346116a75d8:
- ;
return false
}
func rewriteValueAMD64_OpXor64(v *Value, config *Config) bool {
// match: (Xor64 x y)
// cond:
// result: (XORQ x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64XORQ)
v.AddArg(y)
return true
}
- goto endc88cd189c2a6f07ecff324ed94809f8f
-endc88cd189c2a6f07ecff324ed94809f8f:
- ;
return false
}
func rewriteValueAMD64_OpXor8(v *Value, config *Config) bool {
// match: (Xor8 x y)
// cond:
// result: (XORB x y)
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpAMD64XORB)
v.AddArg(y)
return true
}
- goto end50f4434ef96916d3e65ad3cc236d1723
-end50f4434ef96916d3e65ad3cc236d1723:
- ;
return false
}
func rewriteValueAMD64_OpZero(v *Value, config *Config) bool {
// match: (Zero [0] _ mem)
// cond:
// result: mem
- {
+ for {
if v.AuxInt != 0 {
- goto endc9a38a60f0322f93682daa824611272c
+ break
}
mem := v.Args[1]
v.reset(OpCopy)
v.AddArg(mem)
return true
}
- goto endc9a38a60f0322f93682daa824611272c
-endc9a38a60f0322f93682daa824611272c:
- ;
// match: (Zero [1] destptr mem)
// cond:
// result: (MOVBstoreconst [0] destptr mem)
- {
+ for {
if v.AuxInt != 1 {
- goto ende0161981658beee468c9e2368fe31eb8
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto ende0161981658beee468c9e2368fe31eb8
-ende0161981658beee468c9e2368fe31eb8:
- ;
// match: (Zero [2] destptr mem)
// cond:
// result: (MOVWstoreconst [0] destptr mem)
- {
+ for {
if v.AuxInt != 2 {
- goto end4e4aaf641bf2818bb71f1397e4685bdd
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto end4e4aaf641bf2818bb71f1397e4685bdd
-end4e4aaf641bf2818bb71f1397e4685bdd:
- ;
// match: (Zero [4] destptr mem)
// cond:
// result: (MOVLstoreconst [0] destptr mem)
- {
+ for {
if v.AuxInt != 4 {
- goto end7612f59dd66ebfc632ea5bc85f5437b5
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto end7612f59dd66ebfc632ea5bc85f5437b5
-end7612f59dd66ebfc632ea5bc85f5437b5:
- ;
// match: (Zero [8] destptr mem)
// cond:
// result: (MOVQstoreconst [0] destptr mem)
- {
+ for {
if v.AuxInt != 8 {
- goto end07aaaebfa15a48c52cd79b68e28d266f
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(mem)
return true
}
- goto end07aaaebfa15a48c52cd79b68e28d266f
-end07aaaebfa15a48c52cd79b68e28d266f:
- ;
// match: (Zero [3] destptr mem)
// cond:
// result: (MOVBstoreconst [makeValAndOff(0,2)] destptr (MOVWstoreconst [0] destptr mem))
- {
+ for {
if v.AuxInt != 3 {
- goto end3bf4a24a87e0727b9bcfbb5fcd24aabe
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end3bf4a24a87e0727b9bcfbb5fcd24aabe
-end3bf4a24a87e0727b9bcfbb5fcd24aabe:
- ;
// match: (Zero [5] destptr mem)
// cond:
// result: (MOVBstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
- {
+ for {
if v.AuxInt != 5 {
- goto end567e4a90c6867faf1dfc2cd57daf2ce4
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end567e4a90c6867faf1dfc2cd57daf2ce4
-end567e4a90c6867faf1dfc2cd57daf2ce4:
- ;
// match: (Zero [6] destptr mem)
// cond:
// result: (MOVWstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))
- {
+ for {
if v.AuxInt != 6 {
- goto end7cddcaf215fcc2cbca9aa958147b2380
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end7cddcaf215fcc2cbca9aa958147b2380
-end7cddcaf215fcc2cbca9aa958147b2380:
- ;
// match: (Zero [7] destptr mem)
// cond:
// result: (MOVLstoreconst [makeValAndOff(0,3)] destptr (MOVLstoreconst [0] destptr mem))
- {
+ for {
if v.AuxInt != 7 {
- goto end1b58cabccbc912ea4e1cf99be8a9fbf7
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end1b58cabccbc912ea4e1cf99be8a9fbf7
-end1b58cabccbc912ea4e1cf99be8a9fbf7:
- ;
// match: (Zero [size] destptr mem)
// cond: size%8 != 0 && size > 8
// result: (Zero [size-size%8] (ADDQconst destptr [size%8]) (MOVQstoreconst [0] destptr mem))
- {
+ for {
size := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
if !(size%8 != 0 && size > 8) {
- goto endc8760f86b83b1372fce0042ab5200fc1
+ break
}
v.reset(OpZero)
v.AuxInt = size - size%8
v.AddArg(v1)
return true
}
- goto endc8760f86b83b1372fce0042ab5200fc1
-endc8760f86b83b1372fce0042ab5200fc1:
- ;
// match: (Zero [16] destptr mem)
// cond:
// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
- {
+ for {
if v.AuxInt != 16 {
- goto endf1447d60cbf8025adaf1a02a2cd219c4
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto endf1447d60cbf8025adaf1a02a2cd219c4
-endf1447d60cbf8025adaf1a02a2cd219c4:
- ;
// match: (Zero [24] destptr mem)
// cond:
// result: (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)))
- {
+ for {
if v.AuxInt != 24 {
- goto end57f2984a61c64f71a528e7fa75576095
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end57f2984a61c64f71a528e7fa75576095
-end57f2984a61c64f71a528e7fa75576095:
- ;
// match: (Zero [32] destptr mem)
// cond:
// result: (MOVQstoreconst [makeValAndOff(0,24)] destptr (MOVQstoreconst [makeValAndOff(0,16)] destptr (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))))
- {
+ for {
if v.AuxInt != 32 {
- goto end418a59f9f84dd389d37ae5c24aba2760
+ break
}
destptr := v.Args[0]
mem := v.Args[1]
v.AddArg(v0)
return true
}
- goto end418a59f9f84dd389d37ae5c24aba2760
-end418a59f9f84dd389d37ae5c24aba2760:
- ;
// match: (Zero [size] destptr mem)
// cond: size <= 1024 && size%8 == 0 && size%16 != 0
// result: (Zero [size-8] (ADDQconst [8] destptr) (MOVQstore destptr (MOVQconst [0]) mem))
- {
+ for {
size := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
if !(size <= 1024 && size%8 == 0 && size%16 != 0) {
- goto end240266449c3e493db1c3b38a78682ff0
+ break
}
v.reset(OpZero)
v.AuxInt = size - 8
v.AddArg(v1)
return true
}
- goto end240266449c3e493db1c3b38a78682ff0
-end240266449c3e493db1c3b38a78682ff0:
- ;
// match: (Zero [size] destptr mem)
// cond: size <= 1024 && size%16 == 0
// result: (DUFFZERO [duffStart(size)] (ADDQconst [duffAdj(size)] destptr) (MOVOconst [0]) mem)
- {
+ for {
size := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
if !(size <= 1024 && size%16 == 0) {
- goto endf508bb887eee9119069b22c23dbca138
+ break
}
v.reset(OpAMD64DUFFZERO)
v.AuxInt = duffStart(size)
v.AddArg(mem)
return true
}
- goto endf508bb887eee9119069b22c23dbca138
-endf508bb887eee9119069b22c23dbca138:
- ;
// match: (Zero [size] destptr mem)
// cond: size > 1024 && size%8 == 0
// result: (REPSTOSQ destptr (MOVQconst [size/8]) (MOVQconst [0]) mem)
- {
+ for {
size := v.AuxInt
destptr := v.Args[0]
mem := v.Args[1]
if !(size > 1024 && size%8 == 0) {
- goto endb9d55d4ba0e70ed918e3ac757727441b
+ break
}
v.reset(OpAMD64REPSTOSQ)
v.AddArg(destptr)
v.AddArg(mem)
return true
}
- goto endb9d55d4ba0e70ed918e3ac757727441b
-endb9d55d4ba0e70ed918e3ac757727441b:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt16to32(v *Value, config *Config) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVWQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVWQZX)
v.AddArg(x)
return true
}
- goto endbfff79412a2cc96095069c66812844b4
-endbfff79412a2cc96095069c66812844b4:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt16to64(v *Value, config *Config) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVWQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVWQZX)
v.AddArg(x)
return true
}
- goto end7a40262c5c856101058d2bd518ed0910
-end7a40262c5c856101058d2bd518ed0910:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt32to64(v *Value, config *Config) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVLQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVLQZX)
v.AddArg(x)
return true
}
- goto enddf83bdc8cc6c5673a9ef7aca7affe45a
-enddf83bdc8cc6c5673a9ef7aca7affe45a:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt8to16(v *Value, config *Config) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQZX)
v.AddArg(x)
return true
}
- goto endd03d53d2a585727e4107ae1a3cc55479
-endd03d53d2a585727e4107ae1a3cc55479:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt8to32(v *Value, config *Config) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQZX)
v.AddArg(x)
return true
}
- goto endcbd33e965b3dab14fced5ae93d8949de
-endcbd33e965b3dab14fced5ae93d8949de:
- ;
return false
}
func rewriteValueAMD64_OpZeroExt8to64(v *Value, config *Config) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBQZX x)
- {
+ for {
x := v.Args[0]
v.reset(OpAMD64MOVBQZX)
v.AddArg(x)
return true
}
- goto end63ae7cc15db9d15189b2f1342604b2cb
-end63ae7cc15db9d15189b2f1342604b2cb:
- ;
return false
}
func rewriteBlockAMD64(b *Block) bool {
// match: (EQ (InvertFlags cmp) yes no)
// cond:
// result: (EQ cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end6b8e9afc73b1c4d528f31a60d2575fae
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end6b8e9afc73b1c4d528f31a60d2575fae
- end6b8e9afc73b1c4d528f31a60d2575fae:
- ;
// match: (EQ (FlagEQ) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end9ff0ac95bed10cc8e2b88351720bf254
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end9ff0ac95bed10cc8e2b88351720bf254
- end9ff0ac95bed10cc8e2b88351720bf254:
- ;
// match: (EQ (FlagLT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto endb087fca771315fb0f3e36b4f3daa1b4f
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto endb087fca771315fb0f3e36b4f3daa1b4f
- endb087fca771315fb0f3e36b4f3daa1b4f:
- ;
// match: (EQ (FlagLT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto endd1884731c9bd3c1cc1b27617e4573add
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto endd1884731c9bd3c1cc1b27617e4573add
- endd1884731c9bd3c1cc1b27617e4573add:
- ;
// match: (EQ (FlagGT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end13acc127fef124a130ad1e79fd6a58c9
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end13acc127fef124a130ad1e79fd6a58c9
- end13acc127fef124a130ad1e79fd6a58c9:
- ;
// match: (EQ (FlagGT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end4bdb3694a7ed9860cc65f54840b11e84
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end4bdb3694a7ed9860cc65f54840b11e84
- end4bdb3694a7ed9860cc65f54840b11e84:
- ;
case BlockAMD64GE:
// match: (GE (InvertFlags cmp) yes no)
// cond:
// result: (LE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end0610f000a6988ee8310307ec2ea138f8
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end0610f000a6988ee8310307ec2ea138f8
- end0610f000a6988ee8310307ec2ea138f8:
- ;
// match: (GE (FlagEQ) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end24ae40580bbb8675d15f6d1451beeb56
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end24ae40580bbb8675d15f6d1451beeb56
- end24ae40580bbb8675d15f6d1451beeb56:
- ;
// match: (GE (FlagLT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end40cf2bb5d1a99146cc6ce5e9a9dc7eee
- end40cf2bb5d1a99146cc6ce5e9a9dc7eee:
- ;
// match: (GE (FlagLT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end2d4809306e6243116f4c1b27c7c9e503
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end2d4809306e6243116f4c1b27c7c9e503
- end2d4809306e6243116f4c1b27c7c9e503:
- ;
// match: (GE (FlagGT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end842c411ddb1c5583e1e986f2826bb3cf
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end842c411ddb1c5583e1e986f2826bb3cf
- end842c411ddb1c5583e1e986f2826bb3cf:
- ;
// match: (GE (FlagGT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end7402ddc29ccc96070353e9a04e126444
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end7402ddc29ccc96070353e9a04e126444
- end7402ddc29ccc96070353e9a04e126444:
- ;
case BlockAMD64GT:
// match: (GT (InvertFlags cmp) yes no)
// cond:
// result: (LT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto endf60c0660b6a8aa9565c97fc87f04eb34
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endf60c0660b6a8aa9565c97fc87f04eb34
- endf60c0660b6a8aa9565c97fc87f04eb34:
- ;
// match: (GT (FlagEQ) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end2ba8650a12af813cee310b2a81b9ba1b
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end2ba8650a12af813cee310b2a81b9ba1b
- end2ba8650a12af813cee310b2a81b9ba1b:
- ;
// match: (GT (FlagLT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto endbe873b5adbcdd272c99e04e063f9b7ce
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto endbe873b5adbcdd272c99e04e063f9b7ce
- endbe873b5adbcdd272c99e04e063f9b7ce:
- ;
// match: (GT (FlagLT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto ende5dd5906f7fdb5c0e59eeed92a3684d3
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto ende5dd5906f7fdb5c0e59eeed92a3684d3
- ende5dd5906f7fdb5c0e59eeed92a3684d3:
- ;
// match: (GT (FlagGT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end7d92e57429ee02c3707f39d861c94f4c
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end7d92e57429ee02c3707f39d861c94f4c
- end7d92e57429ee02c3707f39d861c94f4c:
- ;
// match: (GT (FlagGT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end9d77d9a15c1b0938558a4ce821d50aa1
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end9d77d9a15c1b0938558a4ce821d50aa1
- end9d77d9a15c1b0938558a4ce821d50aa1:
- ;
case BlockIf:
// match: (If (SETL cmp) yes no)
// cond:
// result: (LT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETL {
- goto end94277282f4b83f0c035b23711a075801
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end94277282f4b83f0c035b23711a075801
- end94277282f4b83f0c035b23711a075801:
- ;
// match: (If (SETLE cmp) yes no)
// cond:
// result: (LE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETLE {
- goto enda84798dd797927b54a9a2987421b2ba2
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto enda84798dd797927b54a9a2987421b2ba2
- enda84798dd797927b54a9a2987421b2ba2:
- ;
// match: (If (SETG cmp) yes no)
// cond:
// result: (GT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETG {
- goto end3434ef985979cbf394455ab5b559567c
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end3434ef985979cbf394455ab5b559567c
- end3434ef985979cbf394455ab5b559567c:
- ;
// match: (If (SETGE cmp) yes no)
// cond:
// result: (GE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETGE {
- goto endee147d81d8620a5e23cb92bd9f13cf8d
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endee147d81d8620a5e23cb92bd9f13cf8d
- endee147d81d8620a5e23cb92bd9f13cf8d:
- ;
// match: (If (SETEQ cmp) yes no)
// cond:
// result: (EQ cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETEQ {
- goto ende7d85ccc850fc3963c50a91df096de17
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto ende7d85ccc850fc3963c50a91df096de17
- ende7d85ccc850fc3963c50a91df096de17:
- ;
// match: (If (SETNE cmp) yes no)
// cond:
// result: (NE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETNE {
- goto endba4b54260ecda1b5731b129c0eb493d0
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endba4b54260ecda1b5731b129c0eb493d0
- endba4b54260ecda1b5731b129c0eb493d0:
- ;
// match: (If (SETB cmp) yes no)
// cond:
// result: (ULT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETB {
- goto endf84eedfcd3f18f5c9c3f3d1045a24330
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endf84eedfcd3f18f5c9c3f3d1045a24330
- endf84eedfcd3f18f5c9c3f3d1045a24330:
- ;
// match: (If (SETBE cmp) yes no)
// cond:
// result: (ULE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETBE {
- goto endfe0178f6f4406945ca8966817d04be60
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endfe0178f6f4406945ca8966817d04be60
- endfe0178f6f4406945ca8966817d04be60:
- ;
// match: (If (SETA cmp) yes no)
// cond:
// result: (UGT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETA {
- goto end2b5a2d7756bdba01a732bf54d9acdb73
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end2b5a2d7756bdba01a732bf54d9acdb73
- end2b5a2d7756bdba01a732bf54d9acdb73:
- ;
// match: (If (SETAE cmp) yes no)
// cond:
// result: (UGE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETAE {
- goto end9bea9963c3c5dfb97249a5feb8287f94
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end9bea9963c3c5dfb97249a5feb8287f94
- end9bea9963c3c5dfb97249a5feb8287f94:
- ;
// match: (If (SETGF cmp) yes no)
// cond:
// result: (UGT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETGF {
- goto enda72d68674cfa26b5982a43756bca6767
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto enda72d68674cfa26b5982a43756bca6767
- enda72d68674cfa26b5982a43756bca6767:
- ;
// match: (If (SETGEF cmp) yes no)
// cond:
// result: (UGE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETGEF {
- goto endccc171c1d66dd60ac0275d1f78259315
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endccc171c1d66dd60ac0275d1f78259315
- endccc171c1d66dd60ac0275d1f78259315:
- ;
// match: (If (SETEQF cmp) yes no)
// cond:
// result: (EQF cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETEQF {
- goto end58cb74d05266a79003ebdd733afb66fa
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end58cb74d05266a79003ebdd733afb66fa
- end58cb74d05266a79003ebdd733afb66fa:
- ;
// match: (If (SETNEF cmp) yes no)
// cond:
// result: (NEF cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64SETNEF {
- goto endaa989df10b5bbc5fdf8f7f0b81767e86
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endaa989df10b5bbc5fdf8f7f0b81767e86
- endaa989df10b5bbc5fdf8f7f0b81767e86:
- ;
// match: (If cond yes no)
// cond:
// result: (NE (TESTB cond cond) yes no)
- {
+ for {
v := b.Control
cond := v
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end5bdbb8d5ea62ff2a76dccf3f9e89d94d
- end5bdbb8d5ea62ff2a76dccf3f9e89d94d:
- ;
case BlockAMD64LE:
// match: (LE (InvertFlags cmp) yes no)
// cond:
// result: (GE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end0d49d7d087fe7578e8015cf13dae37e3
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end0d49d7d087fe7578e8015cf13dae37e3
- end0d49d7d087fe7578e8015cf13dae37e3:
- ;
// match: (LE (FlagEQ) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end794469f5273ff9b2867ec900775c72d2
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end794469f5273ff9b2867ec900775c72d2
- end794469f5273ff9b2867ec900775c72d2:
- ;
// match: (LE (FlagLT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto end0b9fee7a7eb47fe268039bc0e529d6ac
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end0b9fee7a7eb47fe268039bc0e529d6ac
- end0b9fee7a7eb47fe268039bc0e529d6ac:
- ;
// match: (LE (FlagLT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end519d8c93a652b9062fba49942dc7d28d
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end519d8c93a652b9062fba49942dc7d28d
- end519d8c93a652b9062fba49942dc7d28d:
- ;
// match: (LE (FlagGT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto endbd11ec75f000579a43fd6507282b307d
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto endbd11ec75f000579a43fd6507282b307d
- endbd11ec75f000579a43fd6507282b307d:
- ;
// match: (LE (FlagGT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end3828ab56cc3c548c96ac30592e5f865a
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end3828ab56cc3c548c96ac30592e5f865a
- end3828ab56cc3c548c96ac30592e5f865a:
- ;
case BlockAMD64LT:
// match: (LT (InvertFlags cmp) yes no)
// cond:
// result: (GT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end6a408cde0fee0ae7b7da0443c8d902bf
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end6a408cde0fee0ae7b7da0443c8d902bf
- end6a408cde0fee0ae7b7da0443c8d902bf:
- ;
// match: (LT (FlagEQ) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto enda9dfcd37198ce9684d4bb3a2e54feea9
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto enda9dfcd37198ce9684d4bb3a2e54feea9
- enda9dfcd37198ce9684d4bb3a2e54feea9:
- ;
// match: (LT (FlagLT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto ende2b678683d46e68bb0b1503f351917dc
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto ende2b678683d46e68bb0b1503f351917dc
- ende2b678683d46e68bb0b1503f351917dc:
- ;
// match: (LT (FlagLT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end24e744700aa56591fbd23e1335d6e293
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end24e744700aa56591fbd23e1335d6e293
- end24e744700aa56591fbd23e1335d6e293:
- ;
// match: (LT (FlagGT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto enda178f2150e3da5c17e768a4f81af5f9a
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto enda178f2150e3da5c17e768a4f81af5f9a
- enda178f2150e3da5c17e768a4f81af5f9a:
- ;
// match: (LT (FlagGT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end361a42127127ede8ea30e991bb099ebb
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end361a42127127ede8ea30e991bb099ebb
- end361a42127127ede8ea30e991bb099ebb:
- ;
case BlockAMD64NE:
// match: (NE (TESTB (SETL cmp)) yes no)
// cond:
// result: (LT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end0b9ca165d6b395de676eebef94bc62f7
+ break
}
if v.Args[0].Op != OpAMD64SETL {
- goto end0b9ca165d6b395de676eebef94bc62f7
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end0b9ca165d6b395de676eebef94bc62f7
- end0b9ca165d6b395de676eebef94bc62f7:
- ;
// match: (NE (TESTB (SETLE cmp)) yes no)
// cond:
// result: (LE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc
+ break
}
if v.Args[0].Op != OpAMD64SETLE {
- goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endaaba0ee4d0ff8c66a1c3107d2a14c4bc
- endaaba0ee4d0ff8c66a1c3107d2a14c4bc:
- ;
// match: (NE (TESTB (SETG cmp)) yes no)
// cond:
// result: (GT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end1b689463137526b36ba9ceed1e76e512
+ break
}
if v.Args[0].Op != OpAMD64SETG {
- goto end1b689463137526b36ba9ceed1e76e512
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end1b689463137526b36ba9ceed1e76e512
- end1b689463137526b36ba9ceed1e76e512:
- ;
// match: (NE (TESTB (SETGE cmp)) yes no)
// cond:
// result: (GE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end99eefee595c658b997f41577ed853c2e
+ break
}
if v.Args[0].Op != OpAMD64SETGE {
- goto end99eefee595c658b997f41577ed853c2e
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end99eefee595c658b997f41577ed853c2e
- end99eefee595c658b997f41577ed853c2e:
- ;
// match: (NE (TESTB (SETEQ cmp)) yes no)
// cond:
// result: (EQ cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end371b67d3d63e9b92d848b09c3324e8b9
+ break
}
if v.Args[0].Op != OpAMD64SETEQ {
- goto end371b67d3d63e9b92d848b09c3324e8b9
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end371b67d3d63e9b92d848b09c3324e8b9
- end371b67d3d63e9b92d848b09c3324e8b9:
- ;
// match: (NE (TESTB (SETNE cmp)) yes no)
// cond:
// result: (NE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto endd245f2aac2191d32e57cd2e321daa453
+ break
}
if v.Args[0].Op != OpAMD64SETNE {
- goto endd245f2aac2191d32e57cd2e321daa453
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endd245f2aac2191d32e57cd2e321daa453
- endd245f2aac2191d32e57cd2e321daa453:
- ;
// match: (NE (TESTB (SETB cmp)) yes no)
// cond:
// result: (ULT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end90c4bec851e734d37457d611b1a5ff28
+ break
}
if v.Args[0].Op != OpAMD64SETB {
- goto end90c4bec851e734d37457d611b1a5ff28
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end90c4bec851e734d37457d611b1a5ff28
- end90c4bec851e734d37457d611b1a5ff28:
- ;
// match: (NE (TESTB (SETBE cmp)) yes no)
// cond:
// result: (ULE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end3a68a28114e9b89ee0708823386bc1ee
+ break
}
if v.Args[0].Op != OpAMD64SETBE {
- goto end3a68a28114e9b89ee0708823386bc1ee
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end3a68a28114e9b89ee0708823386bc1ee
- end3a68a28114e9b89ee0708823386bc1ee:
- ;
// match: (NE (TESTB (SETA cmp)) yes no)
// cond:
// result: (UGT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end16496f57185756e960d536b057c776c0
+ break
}
if v.Args[0].Op != OpAMD64SETA {
- goto end16496f57185756e960d536b057c776c0
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end16496f57185756e960d536b057c776c0
- end16496f57185756e960d536b057c776c0:
- ;
// match: (NE (TESTB (SETAE cmp)) yes no)
// cond:
// result: (UGE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto endbd122fd599aeb9e60881a0fa735e2fde
+ break
}
if v.Args[0].Op != OpAMD64SETAE {
- goto endbd122fd599aeb9e60881a0fa735e2fde
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endbd122fd599aeb9e60881a0fa735e2fde
- endbd122fd599aeb9e60881a0fa735e2fde:
- ;
// match: (NE (TESTB (SETGF cmp)) yes no)
// cond:
// result: (UGT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto endb2499521f7f351e24757f8c918c3598e
+ break
}
if v.Args[0].Op != OpAMD64SETGF {
- goto endb2499521f7f351e24757f8c918c3598e
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endb2499521f7f351e24757f8c918c3598e
- endb2499521f7f351e24757f8c918c3598e:
- ;
// match: (NE (TESTB (SETGEF cmp)) yes no)
// cond:
// result: (UGE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end20461774babea665c4ca7c4f790a7209
+ break
}
if v.Args[0].Op != OpAMD64SETGEF {
- goto end20461774babea665c4ca7c4f790a7209
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end20461774babea665c4ca7c4f790a7209
- end20461774babea665c4ca7c4f790a7209:
- ;
// match: (NE (TESTB (SETEQF cmp)) yes no)
// cond:
// result: (EQF cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto end236616ef13d489b78736cda7bcc1d168
+ break
}
if v.Args[0].Op != OpAMD64SETEQF {
- goto end236616ef13d489b78736cda7bcc1d168
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end236616ef13d489b78736cda7bcc1d168
- end236616ef13d489b78736cda7bcc1d168:
- ;
// match: (NE (TESTB (SETNEF cmp)) yes no)
// cond:
// result: (NEF cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64TESTB {
- goto endc992f3c266b16cb5f6aa98faa8f55600
+ break
}
if v.Args[0].Op != OpAMD64SETNEF {
- goto endc992f3c266b16cb5f6aa98faa8f55600
+ break
}
cmp := v.Args[0].Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endc992f3c266b16cb5f6aa98faa8f55600
- endc992f3c266b16cb5f6aa98faa8f55600:
- ;
// match: (NE (InvertFlags cmp) yes no)
// cond:
// result: (NE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end713001aba794e50b582fbff930e110af
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end713001aba794e50b582fbff930e110af
- end713001aba794e50b582fbff930e110af:
- ;
// match: (NE (FlagEQ) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end55cc491bc7fc08ef27cadaa80d197545
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end55cc491bc7fc08ef27cadaa80d197545
- end55cc491bc7fc08ef27cadaa80d197545:
- ;
// match: (NE (FlagLT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto end3293c7b37d9fcc6bd5add16c94108a4b
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end3293c7b37d9fcc6bd5add16c94108a4b
- end3293c7b37d9fcc6bd5add16c94108a4b:
- ;
// match: (NE (FlagLT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end1a49ef88420e9d7fd745f9675ca01d6e
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end1a49ef88420e9d7fd745f9675ca01d6e
- end1a49ef88420e9d7fd745f9675ca01d6e:
- ;
// match: (NE (FlagGT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto endbd468825bdf21bca47f8d83d580794ec
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto endbd468825bdf21bca47f8d83d580794ec
- endbd468825bdf21bca47f8d83d580794ec:
- ;
// match: (NE (FlagGT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end43cf7171afb4610818c4b63cc14c1f30
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end43cf7171afb4610818c4b63cc14c1f30
- end43cf7171afb4610818c4b63cc14c1f30:
- ;
case BlockAMD64UGE:
// match: (UGE (InvertFlags cmp) yes no)
// cond:
// result: (ULE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto ende3e4ddc183ca1a46598b11c2d0d13966
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto ende3e4ddc183ca1a46598b11c2d0d13966
- ende3e4ddc183ca1a46598b11c2d0d13966:
- ;
// match: (UGE (FlagEQ) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end13b873811b0cfc7b08501fa2b96cbaa5
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end13b873811b0cfc7b08501fa2b96cbaa5
- end13b873811b0cfc7b08501fa2b96cbaa5:
- ;
// match: (UGE (FlagLT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto end399c10dc3dcdb5864558ecbac4566b7d
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end399c10dc3dcdb5864558ecbac4566b7d
- end399c10dc3dcdb5864558ecbac4566b7d:
- ;
// match: (UGE (FlagLT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end3013dbd3841b20b5030bafb98ee5e38f
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end3013dbd3841b20b5030bafb98ee5e38f
- end3013dbd3841b20b5030bafb98ee5e38f:
- ;
// match: (UGE (FlagGT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end9727eb4bb399457be62dc382bb9a0913
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end9727eb4bb399457be62dc382bb9a0913
- end9727eb4bb399457be62dc382bb9a0913:
- ;
// match: (UGE (FlagGT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto ende4099f954bd6511668fda560c56e89b1
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto ende4099f954bd6511668fda560c56e89b1
- ende4099f954bd6511668fda560c56e89b1:
- ;
case BlockAMD64UGT:
// match: (UGT (InvertFlags cmp) yes no)
// cond:
// result: (ULT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end49818853af2e5251175d06c62768cae7
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end49818853af2e5251175d06c62768cae7
- end49818853af2e5251175d06c62768cae7:
- ;
// match: (UGT (FlagEQ) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end97e91c3348cb91e9278902aaa7fb050a
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end97e91c3348cb91e9278902aaa7fb050a
- end97e91c3348cb91e9278902aaa7fb050a:
- ;
// match: (UGT (FlagLT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto ende2c57da783c6ad18203c9c418ab0de6a
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto ende2c57da783c6ad18203c9c418ab0de6a
- ende2c57da783c6ad18203c9c418ab0de6a:
- ;
// match: (UGT (FlagLT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto end65100b76cf3975a42b235b0e10fea2b1
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end65100b76cf3975a42b235b0e10fea2b1
- end65100b76cf3975a42b235b0e10fea2b1:
- ;
// match: (UGT (FlagGT_ULT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end5db8fa9a32980847176e980aa1899bb3
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end5db8fa9a32980847176e980aa1899bb3
- end5db8fa9a32980847176e980aa1899bb3:
- ;
// match: (UGT (FlagGT_UGT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end1095a388cf1534294952f4ef4ce3e940
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end1095a388cf1534294952f4ef4ce3e940
- end1095a388cf1534294952f4ef4ce3e940:
- ;
case BlockAMD64ULE:
// match: (ULE (InvertFlags cmp) yes no)
// cond:
// result: (UGE cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto endd6698aac0d67261293b558c95ea17b4f
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto endd6698aac0d67261293b558c95ea17b4f
- endd6698aac0d67261293b558c95ea17b4f:
- ;
// match: (ULE (FlagEQ) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end2d801e9ad76753e9ff3e19ee7c9f8a86
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end2d801e9ad76753e9ff3e19ee7c9f8a86
- end2d801e9ad76753e9ff3e19ee7c9f8a86:
- ;
// match: (ULE (FlagLT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto end93b751a70b8587ce2c2dc0545a77246c
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end93b751a70b8587ce2c2dc0545a77246c
- end93b751a70b8587ce2c2dc0545a77246c:
- ;
// match: (ULE (FlagLT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto enda318623645491582b19f9de9b3da20e9
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto enda318623645491582b19f9de9b3da20e9
- enda318623645491582b19f9de9b3da20e9:
- ;
// match: (ULE (FlagGT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end1dfb9e417c0a518e1fa9c92edd57723e
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end1dfb9e417c0a518e1fa9c92edd57723e
- end1dfb9e417c0a518e1fa9c92edd57723e:
- ;
// match: (ULE (FlagGT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end7c9881aac5c0b34d8df3572c8f7b50f3
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end7c9881aac5c0b34d8df3572c8f7b50f3
- end7c9881aac5c0b34d8df3572c8f7b50f3:
- ;
case BlockAMD64ULT:
// match: (ULT (InvertFlags cmp) yes no)
// cond:
// result: (UGT cmp yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64InvertFlags {
- goto end35105dbc9646f02577167e45ae2f2fd2
+ break
}
cmp := v.Args[0]
yes := b.Succs[0]
b.Succs[1] = no
return true
}
- goto end35105dbc9646f02577167e45ae2f2fd2
- end35105dbc9646f02577167e45ae2f2fd2:
- ;
// match: (ULT (FlagEQ) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagEQ {
- goto end4f7ea32f328981623154b68f21c9585f
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end4f7ea32f328981623154b68f21c9585f
- end4f7ea32f328981623154b68f21c9585f:
- ;
// match: (ULT (FlagLT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_ULT {
- goto endf8739cbf4e7cdcb02b891bbfc103654a
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto endf8739cbf4e7cdcb02b891bbfc103654a
- endf8739cbf4e7cdcb02b891bbfc103654a:
- ;
// match: (ULT (FlagLT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagLT_UGT {
- goto enddb12a8de4bdb237aa8a1b6186a0f5f01
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto enddb12a8de4bdb237aa8a1b6186a0f5f01
- enddb12a8de4bdb237aa8a1b6186a0f5f01:
- ;
// match: (ULT (FlagGT_ULT) yes no)
// cond:
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_ULT {
- goto end5ceb130f54533e645b6be48ac28dd7a1
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Succs[1] = no
return true
}
- goto end5ceb130f54533e645b6be48ac28dd7a1
- end5ceb130f54533e645b6be48ac28dd7a1:
- ;
// match: (ULT (FlagGT_UGT) yes no)
// cond:
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpAMD64FlagGT_UGT {
- goto end17191a994592b633cbf6f935efbeaf72
+ break
}
yes := b.Succs[0]
no := b.Succs[1]
b.Likely *= -1
return true
}
- goto end17191a994592b633cbf6f935efbeaf72
- end17191a994592b633cbf6f935efbeaf72:
}
return false
}
// match: (Add16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [c+d])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end359c546ef662b7990116329cb30d6892
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end359c546ef662b7990116329cb30d6892
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = c + d
return true
}
- goto end359c546ef662b7990116329cb30d6892
-end359c546ef662b7990116329cb30d6892:
- ;
// match: (Add16 x (Const16 <t> [c]))
// cond: x.Op != OpConst16
// result: (Add16 (Const16 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end89b69a89778f375b0ebbc683b0c63176
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst16) {
- goto end89b69a89778f375b0ebbc683b0c63176
+ break
}
v.reset(OpAdd16)
v0 := b.NewValue0(v.Line, OpConst16, t)
v.AddArg(x)
return true
}
- goto end89b69a89778f375b0ebbc683b0c63176
-end89b69a89778f375b0ebbc683b0c63176:
- ;
return false
}
func rewriteValuegeneric_OpAdd32(v *Value, config *Config) bool {
// match: (Add32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [c+d])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto enda3edaa9a512bd1d7a95f002c890bfb88
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto enda3edaa9a512bd1d7a95f002c890bfb88
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = c + d
return true
}
- goto enda3edaa9a512bd1d7a95f002c890bfb88
-enda3edaa9a512bd1d7a95f002c890bfb88:
- ;
// match: (Add32 x (Const32 <t> [c]))
// cond: x.Op != OpConst32
// result: (Add32 (Const32 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end28a8c474bfa6968950dce0ed73b14a0b
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst32) {
- goto end28a8c474bfa6968950dce0ed73b14a0b
+ break
}
v.reset(OpAdd32)
v0 := b.NewValue0(v.Line, OpConst32, t)
v.AddArg(x)
return true
}
- goto end28a8c474bfa6968950dce0ed73b14a0b
-end28a8c474bfa6968950dce0ed73b14a0b:
- ;
return false
}
func rewriteValuegeneric_OpAdd64(v *Value, config *Config) bool {
// match: (Add64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c+d])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end8c46df6f85a11cb1d594076b0e467908
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end8c46df6f85a11cb1d594076b0e467908
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = c + d
return true
}
- goto end8c46df6f85a11cb1d594076b0e467908
-end8c46df6f85a11cb1d594076b0e467908:
- ;
// match: (Add64 x (Const64 <t> [c]))
// cond: x.Op != OpConst64
// result: (Add64 (Const64 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end39caa6cf1044f5c47ddbeb062d1a13bd
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst64) {
- goto end39caa6cf1044f5c47ddbeb062d1a13bd
+ break
}
v.reset(OpAdd64)
v0 := b.NewValue0(v.Line, OpConst64, t)
v.AddArg(x)
return true
}
- goto end39caa6cf1044f5c47ddbeb062d1a13bd
-end39caa6cf1044f5c47ddbeb062d1a13bd:
- ;
return false
}
func rewriteValuegeneric_OpAdd8(v *Value, config *Config) bool {
// match: (Add8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [c+d])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end60c66721511a442aade8e4da2fb326bd
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto end60c66721511a442aade8e4da2fb326bd
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = c + d
return true
}
- goto end60c66721511a442aade8e4da2fb326bd
-end60c66721511a442aade8e4da2fb326bd:
- ;
// match: (Add8 x (Const8 <t> [c]))
// cond: x.Op != OpConst8
// result: (Add8 (Const8 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end8c2901b8d12fa5c37f190783b4db8df5
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst8) {
- goto end8c2901b8d12fa5c37f190783b4db8df5
+ break
}
v.reset(OpAdd8)
v0 := b.NewValue0(v.Line, OpConst8, t)
v.AddArg(x)
return true
}
- goto end8c2901b8d12fa5c37f190783b4db8df5
-end8c2901b8d12fa5c37f190783b4db8df5:
- ;
return false
}
func rewriteValuegeneric_OpAnd16(v *Value, config *Config) bool {
// match: (And16 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end69ed6ee2a4fb0491b56c17f3c1926b10
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end69ed6ee2a4fb0491b56c17f3c1926b10
-end69ed6ee2a4fb0491b56c17f3c1926b10:
- ;
return false
}
func rewriteValuegeneric_OpAnd32(v *Value, config *Config) bool {
// match: (And32 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endbbe8c3c5b2ca8f013aa178d856f3a99c
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endbbe8c3c5b2ca8f013aa178d856f3a99c
-endbbe8c3c5b2ca8f013aa178d856f3a99c:
- ;
return false
}
func rewriteValuegeneric_OpAnd64(v *Value, config *Config) bool {
// match: (And64 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endc9736bf24d2e5cd8d662e1bcf3164640
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endc9736bf24d2e5cd8d662e1bcf3164640
-endc9736bf24d2e5cd8d662e1bcf3164640:
- ;
return false
}
func rewriteValuegeneric_OpAnd8(v *Value, config *Config) bool {
// match: (And8 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endeaf127389bd0d4b0e0e297830f8f463b
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endeaf127389bd0d4b0e0e297830f8f463b
-endeaf127389bd0d4b0e0e297830f8f463b:
- ;
return false
}
func rewriteValuegeneric_OpArg(v *Value, config *Config) bool {
// match: (Arg {n} [off])
// cond: v.Type.IsString()
// result: (StringMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]))
- {
+ for {
n := v.Aux
off := v.AuxInt
if !(v.Type.IsString()) {
- goto end939d3f946bf61eb85b46b374e7afa9e9
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto end939d3f946bf61eb85b46b374e7afa9e9
-end939d3f946bf61eb85b46b374e7afa9e9:
- ;
// match: (Arg {n} [off])
// cond: v.Type.IsSlice()
// result: (SliceMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeInt()> {n} [off+config.PtrSize]) (Arg <config.fe.TypeInt()> {n} [off+2*config.PtrSize]))
- {
+ for {
n := v.Aux
off := v.AuxInt
if !(v.Type.IsSlice()) {
- goto endab4b93ad3b1cf55e5bf25d1fd9cd498e
+ break
}
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
v.AddArg(v2)
return true
}
- goto endab4b93ad3b1cf55e5bf25d1fd9cd498e
-endab4b93ad3b1cf55e5bf25d1fd9cd498e:
- ;
// match: (Arg {n} [off])
// cond: v.Type.IsInterface()
// result: (IMake (Arg <config.fe.TypeBytePtr()> {n} [off]) (Arg <config.fe.TypeBytePtr()> {n} [off+config.PtrSize]))
- {
+ for {
n := v.Aux
off := v.AuxInt
if !(v.Type.IsInterface()) {
- goto end851de8e588a39e81b4e2aef06566bf3e
+ break
}
v.reset(OpIMake)
v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto end851de8e588a39e81b4e2aef06566bf3e
-end851de8e588a39e81b4e2aef06566bf3e:
- ;
// match: (Arg {n} [off])
// cond: v.Type.IsComplex() && v.Type.Size() == 16
// result: (ComplexMake (Arg <config.fe.TypeFloat64()> {n} [off]) (Arg <config.fe.TypeFloat64()> {n} [off+8]))
- {
+ for {
n := v.Aux
off := v.AuxInt
if !(v.Type.IsComplex() && v.Type.Size() == 16) {
- goto end0988fc6a62c810b2f4976cb6cf44387f
+ break
}
v.reset(OpComplexMake)
v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat64())
v.AddArg(v1)
return true
}
- goto end0988fc6a62c810b2f4976cb6cf44387f
-end0988fc6a62c810b2f4976cb6cf44387f:
- ;
// match: (Arg {n} [off])
// cond: v.Type.IsComplex() && v.Type.Size() == 8
// result: (ComplexMake (Arg <config.fe.TypeFloat32()> {n} [off]) (Arg <config.fe.TypeFloat32()> {n} [off+4]))
- {
+ for {
n := v.Aux
off := v.AuxInt
if !(v.Type.IsComplex() && v.Type.Size() == 8) {
- goto enda348e93e0036873dd7089a2939c22e3e
+ break
}
v.reset(OpComplexMake)
v0 := b.NewValue0(v.Line, OpArg, config.fe.TypeFloat32())
v.AddArg(v1)
return true
}
- goto enda348e93e0036873dd7089a2939c22e3e
-enda348e93e0036873dd7089a2939c22e3e:
- ;
// match: (Arg <t>)
// cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)
// result: (StructMake0)
- {
+ for {
t := v.Type
if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) {
- goto ende233eeefa826638b0e541bcca531d701
+ break
}
v.reset(OpStructMake0)
return true
}
- goto ende233eeefa826638b0e541bcca531d701
-ende233eeefa826638b0e541bcca531d701:
- ;
// match: (Arg <t> {n} [off])
// cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)
// result: (StructMake1 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]))
- {
+ for {
t := v.Type
n := v.Aux
off := v.AuxInt
if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) {
- goto ende953e77a0617051dd3f7ad4d58c9ab37
+ break
}
v.reset(OpStructMake1)
v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
v.AddArg(v0)
return true
}
- goto ende953e77a0617051dd3f7ad4d58c9ab37
-ende953e77a0617051dd3f7ad4d58c9ab37:
- ;
// match: (Arg <t> {n} [off])
// cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)
// result: (StructMake2 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]))
- {
+ for {
t := v.Type
n := v.Aux
off := v.AuxInt
if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) {
- goto end9a008048978aabad9de0723212e60631
+ break
}
v.reset(OpStructMake2)
v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
v.AddArg(v1)
return true
}
- goto end9a008048978aabad9de0723212e60631
-end9a008048978aabad9de0723212e60631:
- ;
// match: (Arg <t> {n} [off])
// cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)
// result: (StructMake3 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]))
- {
+ for {
t := v.Type
n := v.Aux
off := v.AuxInt
if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) {
- goto end0196e61dbeebc6402f3aa1e9a182210b
+ break
}
v.reset(OpStructMake3)
v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
v.AddArg(v2)
return true
}
- goto end0196e61dbeebc6402f3aa1e9a182210b
-end0196e61dbeebc6402f3aa1e9a182210b:
- ;
// match: (Arg <t> {n} [off])
// cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)
// result: (StructMake4 (Arg <t.FieldType(0)> {n} [off+t.FieldOff(0)]) (Arg <t.FieldType(1)> {n} [off+t.FieldOff(1)]) (Arg <t.FieldType(2)> {n} [off+t.FieldOff(2)]) (Arg <t.FieldType(3)> {n} [off+t.FieldOff(3)]))
- {
+ for {
t := v.Type
n := v.Aux
off := v.AuxInt
if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) {
- goto end6bc133c93e50cb14c2e6cc9401850738
+ break
}
v.reset(OpStructMake4)
v0 := b.NewValue0(v.Line, OpArg, t.FieldType(0))
v.AddArg(v3)
return true
}
- goto end6bc133c93e50cb14c2e6cc9401850738
-end6bc133c93e50cb14c2e6cc9401850738:
- ;
return false
}
func rewriteValuegeneric_OpArrayIndex(v *Value, config *Config) bool {
// match: (ArrayIndex (Load ptr mem) idx)
// cond: b == v.Args[0].Block
// result: (Load (PtrIndex <v.Type.PtrTo()> ptr idx) mem)
- {
+ for {
if v.Args[0].Op != OpLoad {
- goto end68b373270d9d605c420497edefaa71df
+ break
}
ptr := v.Args[0].Args[0]
mem := v.Args[0].Args[1]
idx := v.Args[1]
if !(b == v.Args[0].Block) {
- goto end68b373270d9d605c420497edefaa71df
+ break
}
v.reset(OpLoad)
v0 := b.NewValue0(v.Line, OpPtrIndex, v.Type.PtrTo())
v.AddArg(mem)
return true
}
- goto end68b373270d9d605c420497edefaa71df
-end68b373270d9d605c420497edefaa71df:
- ;
return false
}
func rewriteValuegeneric_OpCom16(v *Value, config *Config) bool {
// match: (Com16 (Com16 x))
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpCom16 {
- goto end1ea17710dd4dd7ba4e710e0e4c7b5a56
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end1ea17710dd4dd7ba4e710e0e4c7b5a56
-end1ea17710dd4dd7ba4e710e0e4c7b5a56:
- ;
return false
}
func rewriteValuegeneric_OpCom32(v *Value, config *Config) bool {
// match: (Com32 (Com32 x))
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpCom32 {
- goto end9a04ed536496e292c27bef4414128cbf
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end9a04ed536496e292c27bef4414128cbf
-end9a04ed536496e292c27bef4414128cbf:
- ;
return false
}
func rewriteValuegeneric_OpCom64(v *Value, config *Config) bool {
// match: (Com64 (Com64 x))
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpCom64 {
- goto ended44e29d5968f0f7b86972b7bf417ab3
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto ended44e29d5968f0f7b86972b7bf417ab3
-ended44e29d5968f0f7b86972b7bf417ab3:
- ;
return false
}
func rewriteValuegeneric_OpCom8(v *Value, config *Config) bool {
// match: (Com8 (Com8 x))
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpCom8 {
- goto end4d92ff3ba567d9afd38fc9ca113602ad
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end4d92ff3ba567d9afd38fc9ca113602ad
-end4d92ff3ba567d9afd38fc9ca113602ad:
- ;
return false
}
func rewriteValuegeneric_OpComplexImag(v *Value, config *Config) bool {
// match: (ComplexImag (ComplexMake _ imag ))
// cond:
// result: imag
- {
+ for {
if v.Args[0].Op != OpComplexMake {
- goto endec3009fd8727d03002021997936e091f
+ break
}
imag := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(imag)
return true
}
- goto endec3009fd8727d03002021997936e091f
-endec3009fd8727d03002021997936e091f:
- ;
return false
}
func rewriteValuegeneric_OpComplexReal(v *Value, config *Config) bool {
// match: (ComplexReal (ComplexMake real _ ))
// cond:
// result: real
- {
+ for {
if v.Args[0].Op != OpComplexMake {
- goto end8db3e16bd59af1adaa4b734c8adcc71d
+ break
}
real := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(real)
return true
}
- goto end8db3e16bd59af1adaa4b734c8adcc71d
-end8db3e16bd59af1adaa4b734c8adcc71d:
- ;
return false
}
func rewriteValuegeneric_OpConstInterface(v *Value, config *Config) bool {
// match: (ConstInterface)
// cond:
// result: (IMake (ConstNil <config.fe.TypeBytePtr()>) (ConstNil <config.fe.TypeBytePtr()>))
- {
+ for {
v.reset(OpIMake)
v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
v.AddArg(v0)
v.AddArg(v1)
return true
}
- goto end0367bd8f20a320cc41568f2b28657f6b
-end0367bd8f20a320cc41568f2b28657f6b:
- ;
return false
}
func rewriteValuegeneric_OpConstSlice(v *Value, config *Config) bool {
// match: (ConstSlice)
// cond: config.PtrSize == 4
// result: (SliceMake (ConstNil <config.fe.TypeBytePtr()>) (Const32 <config.fe.TypeInt()> [0]) (Const32 <config.fe.TypeInt()> [0]))
- {
+ for {
if !(config.PtrSize == 4) {
- goto end9ba6baf9c7247b1f5ba4099c0c3910ce
+ break
}
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
v.AddArg(v2)
return true
}
- goto end9ba6baf9c7247b1f5ba4099c0c3910ce
-end9ba6baf9c7247b1f5ba4099c0c3910ce:
- ;
// match: (ConstSlice)
// cond: config.PtrSize == 8
// result: (SliceMake (ConstNil <config.fe.TypeBytePtr()>) (Const64 <config.fe.TypeInt()> [0]) (Const64 <config.fe.TypeInt()> [0]))
- {
+ for {
if !(config.PtrSize == 8) {
- goto endabee2aa6bd3e3261628f677221ad2640
+ break
}
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
v.AddArg(v2)
return true
}
- goto endabee2aa6bd3e3261628f677221ad2640
-endabee2aa6bd3e3261628f677221ad2640:
- ;
return false
}
func rewriteValuegeneric_OpConstString(v *Value, config *Config) bool {
// match: (ConstString {s})
// cond: config.PtrSize == 4 && s.(string) == ""
// result: (StringMake (ConstNil) (Const32 <config.fe.TypeInt()> [0]))
- {
+ for {
s := v.Aux
if !(config.PtrSize == 4 && s.(string) == "") {
- goto end85d5f388ba947643af63cdc68c1155a5
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto end85d5f388ba947643af63cdc68c1155a5
-end85d5f388ba947643af63cdc68c1155a5:
- ;
// match: (ConstString {s})
// cond: config.PtrSize == 8 && s.(string) == ""
// result: (StringMake (ConstNil) (Const64 <config.fe.TypeInt()> [0]))
- {
+ for {
s := v.Aux
if !(config.PtrSize == 8 && s.(string) == "") {
- goto endc807259a5ed2760fbbd3dc7386641343
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpConstNil, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto endc807259a5ed2760fbbd3dc7386641343
-endc807259a5ed2760fbbd3dc7386641343:
- ;
// match: (ConstString {s})
// cond: config.PtrSize == 4 && s.(string) != ""
// result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const32 <config.fe.TypeInt()> [int64(len(s.(string)))]))
- {
+ for {
s := v.Aux
if !(config.PtrSize == 4 && s.(string) != "") {
- goto end107a700a4519d18f418602421444ddb6
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr())
v.AddArg(v2)
return true
}
- goto end107a700a4519d18f418602421444ddb6
-end107a700a4519d18f418602421444ddb6:
- ;
// match: (ConstString {s})
// cond: config.PtrSize == 8 && s.(string) != ""
// result: (StringMake (Addr <config.fe.TypeBytePtr()> {config.fe.StringData(s.(string))} (SB)) (Const64 <config.fe.TypeInt()> [int64(len(s.(string)))]))
- {
+ for {
s := v.Aux
if !(config.PtrSize == 8 && s.(string) != "") {
- goto end7ce9db29d17866f26d21e6e12f442e54
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpAddr, config.fe.TypeBytePtr())
v.AddArg(v2)
return true
}
- goto end7ce9db29d17866f26d21e6e12f442e54
-end7ce9db29d17866f26d21e6e12f442e54:
- ;
return false
}
func rewriteValuegeneric_OpConvert(v *Value, config *Config) bool {
// match: (Convert (Add64 (Convert ptr mem) off) mem)
// cond:
// result: (Add64 ptr off)
- {
+ for {
if v.Args[0].Op != OpAdd64 {
- goto endbbc9f1666b4d39a130e1b86f109e7c1b
+ break
}
if v.Args[0].Args[0].Op != OpConvert {
- goto endbbc9f1666b4d39a130e1b86f109e7c1b
+ break
}
ptr := v.Args[0].Args[0].Args[0]
mem := v.Args[0].Args[0].Args[1]
off := v.Args[0].Args[1]
if v.Args[1] != mem {
- goto endbbc9f1666b4d39a130e1b86f109e7c1b
+ break
}
v.reset(OpAdd64)
v.AddArg(ptr)
v.AddArg(off)
return true
}
- goto endbbc9f1666b4d39a130e1b86f109e7c1b
-endbbc9f1666b4d39a130e1b86f109e7c1b:
- ;
// match: (Convert (Convert ptr mem) mem)
// cond:
// result: ptr
- {
+ for {
if v.Args[0].Op != OpConvert {
- goto end98c5e0ca257eb216989171786f91b42d
+ break
}
ptr := v.Args[0].Args[0]
mem := v.Args[0].Args[1]
if v.Args[1] != mem {
- goto end98c5e0ca257eb216989171786f91b42d
+ break
}
v.reset(OpCopy)
v.Type = ptr.Type
v.AddArg(ptr)
return true
}
- goto end98c5e0ca257eb216989171786f91b42d
-end98c5e0ca257eb216989171786f91b42d:
- ;
return false
}
func rewriteValuegeneric_OpEq16(v *Value, config *Config) bool {
// match: (Eq16 x x)
// cond:
// result: (ConstBool [1])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end0c0fe5fdfba3821add3448fd3f1fc6b7
+ break
}
v.reset(OpConstBool)
v.AuxInt = 1
return true
}
- goto end0c0fe5fdfba3821add3448fd3f1fc6b7
-end0c0fe5fdfba3821add3448fd3f1fc6b7:
- ;
// match: (Eq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
// cond:
// result: (Eq16 (Const16 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end79c830afa265161fc0f0532c4c4e7f50
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd16 {
- goto end79c830afa265161fc0f0532c4c4e7f50
+ break
}
if v.Args[1].Args[0].Op != OpConst16 {
- goto end79c830afa265161fc0f0532c4c4e7f50
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto end79c830afa265161fc0f0532c4c4e7f50
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto end79c830afa265161fc0f0532c4c4e7f50
-end79c830afa265161fc0f0532c4c4e7f50:
- ;
// match: (Eq16 x (Const16 <t> [c]))
// cond: x.Op != OpConst16
// result: (Eq16 (Const16 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end5d89fe1eeb145f14e11578f41282c904
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst16) {
- goto end5d89fe1eeb145f14e11578f41282c904
+ break
}
v.reset(OpEq16)
v0 := b.NewValue0(v.Line, OpConst16, t)
v.AddArg(x)
return true
}
- goto end5d89fe1eeb145f14e11578f41282c904
-end5d89fe1eeb145f14e11578f41282c904:
- ;
// match: (Eq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) == int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end4532e1d01c10d8906fe1da14f9dfaa88
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end4532e1d01c10d8906fe1da14f9dfaa88
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) == int16(d))
return true
}
- goto end4532e1d01c10d8906fe1da14f9dfaa88
-end4532e1d01c10d8906fe1da14f9dfaa88:
- ;
return false
}
func rewriteValuegeneric_OpEq32(v *Value, config *Config) bool {
// match: (Eq32 x x)
// cond:
// result: (ConstBool [1])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end6da547ec4ee93d787434f3bda873e4a0
+ break
}
v.reset(OpConstBool)
v.AuxInt = 1
return true
}
- goto end6da547ec4ee93d787434f3bda873e4a0
-end6da547ec4ee93d787434f3bda873e4a0:
- ;
// match: (Eq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
// cond:
// result: (Eq32 (Const32 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end1a69730a32c6e432784dcdf643320ecd
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd32 {
- goto end1a69730a32c6e432784dcdf643320ecd
+ break
}
if v.Args[1].Args[0].Op != OpConst32 {
- goto end1a69730a32c6e432784dcdf643320ecd
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto end1a69730a32c6e432784dcdf643320ecd
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto end1a69730a32c6e432784dcdf643320ecd
-end1a69730a32c6e432784dcdf643320ecd:
- ;
// match: (Eq32 x (Const32 <t> [c]))
// cond: x.Op != OpConst32
// result: (Eq32 (Const32 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end0ca4ef4cf416ec3083d38667e263cf45
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst32) {
- goto end0ca4ef4cf416ec3083d38667e263cf45
+ break
}
v.reset(OpEq32)
v0 := b.NewValue0(v.Line, OpConst32, t)
v.AddArg(x)
return true
}
- goto end0ca4ef4cf416ec3083d38667e263cf45
-end0ca4ef4cf416ec3083d38667e263cf45:
- ;
// match: (Eq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) == int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end00a2464e02c9ca00e8d0077acacbb5ad
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end00a2464e02c9ca00e8d0077acacbb5ad
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) == int32(d))
return true
}
- goto end00a2464e02c9ca00e8d0077acacbb5ad
-end00a2464e02c9ca00e8d0077acacbb5ad:
- ;
return false
}
func rewriteValuegeneric_OpEq64(v *Value, config *Config) bool {
// match: (Eq64 x x)
// cond:
// result: (ConstBool [1])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endb1d471cc503ba8bb05440f01dbf33d81
+ break
}
v.reset(OpConstBool)
v.AuxInt = 1
return true
}
- goto endb1d471cc503ba8bb05440f01dbf33d81
-endb1d471cc503ba8bb05440f01dbf33d81:
- ;
// match: (Eq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
// cond:
// result: (Eq64 (Const64 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto endffd67f3b83f6972cd459153d318f714d
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd64 {
- goto endffd67f3b83f6972cd459153d318f714d
+ break
}
if v.Args[1].Args[0].Op != OpConst64 {
- goto endffd67f3b83f6972cd459153d318f714d
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto endffd67f3b83f6972cd459153d318f714d
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto endffd67f3b83f6972cd459153d318f714d
-endffd67f3b83f6972cd459153d318f714d:
- ;
// match: (Eq64 x (Const64 <t> [c]))
// cond: x.Op != OpConst64
// result: (Eq64 (Const64 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto endc2ecf8254dc736e97c5815362d0b477d
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst64) {
- goto endc2ecf8254dc736e97c5815362d0b477d
+ break
}
v.reset(OpEq64)
v0 := b.NewValue0(v.Line, OpConst64, t)
v.AddArg(x)
return true
}
- goto endc2ecf8254dc736e97c5815362d0b477d
-endc2ecf8254dc736e97c5815362d0b477d:
- ;
// match: (Eq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) == int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end405568a707dbbc86432e91f4ce7d97d7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end405568a707dbbc86432e91f4ce7d97d7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) == int64(d))
return true
}
- goto end405568a707dbbc86432e91f4ce7d97d7
-end405568a707dbbc86432e91f4ce7d97d7:
- ;
return false
}
func rewriteValuegeneric_OpEq8(v *Value, config *Config) bool {
// match: (Eq8 x x)
// cond:
// result: (ConstBool [1])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto enda66da0d3e7e51624ee46527727c48a9a
+ break
}
v.reset(OpConstBool)
v.AuxInt = 1
return true
}
- goto enda66da0d3e7e51624ee46527727c48a9a
-enda66da0d3e7e51624ee46527727c48a9a:
- ;
// match: (Eq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
// cond:
// result: (Eq8 (Const8 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end6912961350bb485f56ef176522aa683b
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd8 {
- goto end6912961350bb485f56ef176522aa683b
+ break
}
if v.Args[1].Args[0].Op != OpConst8 {
- goto end6912961350bb485f56ef176522aa683b
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto end6912961350bb485f56ef176522aa683b
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto end6912961350bb485f56ef176522aa683b
-end6912961350bb485f56ef176522aa683b:
- ;
// match: (Eq8 x (Const8 <t> [c]))
// cond: x.Op != OpConst8
// result: (Eq8 (Const8 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end70d0b569427b24e7a912a1aa8fab3b20
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst8) {
- goto end70d0b569427b24e7a912a1aa8fab3b20
+ break
}
v.reset(OpEq8)
v0 := b.NewValue0(v.Line, OpConst8, t)
v.AddArg(x)
return true
}
- goto end70d0b569427b24e7a912a1aa8fab3b20
-end70d0b569427b24e7a912a1aa8fab3b20:
- ;
// match: (Eq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) == int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endd49f3700ba2d1e500d3ab4fa34fd090d
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endd49f3700ba2d1e500d3ab4fa34fd090d
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) == int8(d))
return true
}
- goto endd49f3700ba2d1e500d3ab4fa34fd090d
-endd49f3700ba2d1e500d3ab4fa34fd090d:
- ;
return false
}
func rewriteValuegeneric_OpEqInter(v *Value, config *Config) bool {
// match: (EqInter x y)
// cond:
// result: (EqPtr (ITab x) (ITab y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpEqPtr)
v.AddArg(v1)
return true
}
- goto end1cc40483caab33ece971ab7e6c8fdfca
-end1cc40483caab33ece971ab7e6c8fdfca:
- ;
return false
}
func rewriteValuegeneric_OpEqPtr(v *Value, config *Config) bool {
// match: (EqPtr p (ConstNil))
// cond:
// result: (Not (IsNonNil p))
- {
+ for {
p := v.Args[0]
if v.Args[1].Op != OpConstNil {
- goto ende701cdb6a2c1fff4d4b283b7f8f6178b
+ break
}
v.reset(OpNot)
v0 := b.NewValue0(v.Line, OpIsNonNil, config.fe.TypeBool())
v.AddArg(v0)
return true
}
- goto ende701cdb6a2c1fff4d4b283b7f8f6178b
-ende701cdb6a2c1fff4d4b283b7f8f6178b:
- ;
// match: (EqPtr (ConstNil) p)
// cond:
// result: (Not (IsNonNil p))
- {
+ for {
if v.Args[0].Op != OpConstNil {
- goto end7cdc0d5c38fbffe6287c8928803b038e
+ break
}
p := v.Args[1]
v.reset(OpNot)
v.AddArg(v0)
return true
}
- goto end7cdc0d5c38fbffe6287c8928803b038e
-end7cdc0d5c38fbffe6287c8928803b038e:
- ;
return false
}
func rewriteValuegeneric_OpEqSlice(v *Value, config *Config) bool {
// match: (EqSlice x y)
// cond:
// result: (EqPtr (SlicePtr x) (SlicePtr y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpEqPtr)
v.AddArg(v1)
return true
}
- goto end9cd53ca57ee90aa09c54f8071c8e8769
-end9cd53ca57ee90aa09c54f8071c8e8769:
- ;
return false
}
func rewriteValuegeneric_OpGeq16(v *Value, config *Config) bool {
// match: (Geq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) >= int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto endbac100e9f1065e7d2ff863951f686f4b
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto endbac100e9f1065e7d2ff863951f686f4b
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) >= int16(d))
return true
}
- goto endbac100e9f1065e7d2ff863951f686f4b
-endbac100e9f1065e7d2ff863951f686f4b:
- ;
return false
}
func rewriteValuegeneric_OpGeq16U(v *Value, config *Config) bool {
// match: (Geq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end11c6acbc5827fc9508424b0ffcf98b34
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end11c6acbc5827fc9508424b0ffcf98b34
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint16(c) >= uint16(d))
return true
}
- goto end11c6acbc5827fc9508424b0ffcf98b34
-end11c6acbc5827fc9508424b0ffcf98b34:
- ;
return false
}
func rewriteValuegeneric_OpGeq32(v *Value, config *Config) bool {
// match: (Geq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) >= int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end89ced97524ac75045911ca7cf6d44b28
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end89ced97524ac75045911ca7cf6d44b28
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) >= int32(d))
return true
}
- goto end89ced97524ac75045911ca7cf6d44b28
-end89ced97524ac75045911ca7cf6d44b28:
- ;
return false
}
func rewriteValuegeneric_OpGeq32U(v *Value, config *Config) bool {
// match: (Geq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end92fbe85c7bbbf0db287932822bdde991
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end92fbe85c7bbbf0db287932822bdde991
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint32(c) >= uint32(d))
return true
}
- goto end92fbe85c7bbbf0db287932822bdde991
-end92fbe85c7bbbf0db287932822bdde991:
- ;
return false
}
func rewriteValuegeneric_OpGeq64(v *Value, config *Config) bool {
// match: (Geq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) >= int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end08a5a4bff12a346befe05ad561b080ac
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end08a5a4bff12a346befe05ad561b080ac
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) >= int64(d))
return true
}
- goto end08a5a4bff12a346befe05ad561b080ac
-end08a5a4bff12a346befe05ad561b080ac:
- ;
return false
}
func rewriteValuegeneric_OpGeq64U(v *Value, config *Config) bool {
// match: (Geq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto endd72c497b6cc2b01d43a39ec12d5010b3
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endd72c497b6cc2b01d43a39ec12d5010b3
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint64(c) >= uint64(d))
return true
}
- goto endd72c497b6cc2b01d43a39ec12d5010b3
-endd72c497b6cc2b01d43a39ec12d5010b3:
- ;
return false
}
func rewriteValuegeneric_OpGeq8(v *Value, config *Config) bool {
// match: (Geq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) >= int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endea141068e84038c63cbdd87a8cb227d7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endea141068e84038c63cbdd87a8cb227d7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) >= int8(d))
return true
}
- goto endea141068e84038c63cbdd87a8cb227d7
-endea141068e84038c63cbdd87a8cb227d7:
- ;
return false
}
func rewriteValuegeneric_OpGeq8U(v *Value, config *Config) bool {
// match: (Geq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) >= uint8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end47c128ccdc54151a243c5856b0c52ef1
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto end47c128ccdc54151a243c5856b0c52ef1
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint8(c) >= uint8(d))
return true
}
- goto end47c128ccdc54151a243c5856b0c52ef1
-end47c128ccdc54151a243c5856b0c52ef1:
- ;
return false
}
func rewriteValuegeneric_OpGreater16(v *Value, config *Config) bool {
// match: (Greater16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) > int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end390bae49463ace4d703dd24e18920f66
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end390bae49463ace4d703dd24e18920f66
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) > int16(d))
return true
}
- goto end390bae49463ace4d703dd24e18920f66
-end390bae49463ace4d703dd24e18920f66:
- ;
return false
}
func rewriteValuegeneric_OpGreater16U(v *Value, config *Config) bool {
// match: (Greater16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) > uint16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end89ba3caf5c156fa6d908ac04c058187b
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end89ba3caf5c156fa6d908ac04c058187b
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint16(c) > uint16(d))
return true
}
- goto end89ba3caf5c156fa6d908ac04c058187b
-end89ba3caf5c156fa6d908ac04c058187b:
- ;
return false
}
func rewriteValuegeneric_OpGreater32(v *Value, config *Config) bool {
// match: (Greater32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) > int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end86482a9dc6439e8470da5352dd74d68d
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end86482a9dc6439e8470da5352dd74d68d
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) > int32(d))
return true
}
- goto end86482a9dc6439e8470da5352dd74d68d
-end86482a9dc6439e8470da5352dd74d68d:
- ;
return false
}
func rewriteValuegeneric_OpGreater32U(v *Value, config *Config) bool {
// match: (Greater32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) > uint32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end1bf3f05c1e3599a969b8be1f5f6949e4
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end1bf3f05c1e3599a969b8be1f5f6949e4
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint32(c) > uint32(d))
return true
}
- goto end1bf3f05c1e3599a969b8be1f5f6949e4
-end1bf3f05c1e3599a969b8be1f5f6949e4:
- ;
return false
}
func rewriteValuegeneric_OpGreater64(v *Value, config *Config) bool {
// match: (Greater64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) > int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end96a82e893fda4882f23b6bab5f7fbff7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end96a82e893fda4882f23b6bab5f7fbff7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) > int64(d))
return true
}
- goto end96a82e893fda4882f23b6bab5f7fbff7
-end96a82e893fda4882f23b6bab5f7fbff7:
- ;
return false
}
func rewriteValuegeneric_OpGreater64U(v *Value, config *Config) bool {
// match: (Greater64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) > uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end2d8f5ad85fbffeb92af985a888f6fa69
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end2d8f5ad85fbffeb92af985a888f6fa69
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint64(c) > uint64(d))
return true
}
- goto end2d8f5ad85fbffeb92af985a888f6fa69
-end2d8f5ad85fbffeb92af985a888f6fa69:
- ;
return false
}
func rewriteValuegeneric_OpGreater8(v *Value, config *Config) bool {
// match: (Greater8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) > int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto ende221967c7516b7749109cf8343fe9c83
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto ende221967c7516b7749109cf8343fe9c83
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) > int8(d))
return true
}
- goto ende221967c7516b7749109cf8343fe9c83
-ende221967c7516b7749109cf8343fe9c83:
- ;
return false
}
func rewriteValuegeneric_OpGreater8U(v *Value, config *Config) bool {
// match: (Greater8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) > uint8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto enda9398c8188156dd46689fa2939147525
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto enda9398c8188156dd46689fa2939147525
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint8(c) > uint8(d))
return true
}
- goto enda9398c8188156dd46689fa2939147525
-enda9398c8188156dd46689fa2939147525:
- ;
return false
}
func rewriteValuegeneric_OpIData(v *Value, config *Config) bool {
// match: (IData (IMake _ data))
// cond:
// result: data
- {
+ for {
if v.Args[0].Op != OpIMake {
- goto endbfa1bb944cdc07933effb16a35152e12
+ break
}
data := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(data)
return true
}
- goto endbfa1bb944cdc07933effb16a35152e12
-endbfa1bb944cdc07933effb16a35152e12:
- ;
return false
}
func rewriteValuegeneric_OpITab(v *Value, config *Config) bool {
// match: (ITab (IMake itab _))
// cond:
// result: itab
- {
+ for {
if v.Args[0].Op != OpIMake {
- goto endfcbb9414a776ff9c8512da3e0f4d8fbd
+ break
}
itab := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(itab)
return true
}
- goto endfcbb9414a776ff9c8512da3e0f4d8fbd
-endfcbb9414a776ff9c8512da3e0f4d8fbd:
- ;
return false
}
func rewriteValuegeneric_OpIsInBounds(v *Value, config *Config) bool {
// match: (IsInBounds (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(inBounds32(c,d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto endf0a2ecfe84b293de6ff0919e45d19d9d
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto endf0a2ecfe84b293de6ff0919e45d19d9d
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(inBounds32(c, d))
return true
}
- goto endf0a2ecfe84b293de6ff0919e45d19d9d
-endf0a2ecfe84b293de6ff0919e45d19d9d:
- ;
// match: (IsInBounds (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(inBounds64(c,d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end4b406f402c135f50f71effcc904ecb2b
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end4b406f402c135f50f71effcc904ecb2b
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(inBounds64(c, d))
return true
}
- goto end4b406f402c135f50f71effcc904ecb2b
-end4b406f402c135f50f71effcc904ecb2b:
- ;
return false
}
func rewriteValuegeneric_OpIsSliceInBounds(v *Value, config *Config) bool {
// match: (IsSliceInBounds (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(sliceInBounds32(c,d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end5e84a230c28cac987437cfed8f432cc3
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end5e84a230c28cac987437cfed8f432cc3
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(sliceInBounds32(c, d))
return true
}
- goto end5e84a230c28cac987437cfed8f432cc3
-end5e84a230c28cac987437cfed8f432cc3:
- ;
// match: (IsSliceInBounds (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(sliceInBounds64(c,d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end3880a6fe20ad4152e98f76d84da233a7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end3880a6fe20ad4152e98f76d84da233a7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(sliceInBounds64(c, d))
return true
}
- goto end3880a6fe20ad4152e98f76d84da233a7
-end3880a6fe20ad4152e98f76d84da233a7:
- ;
return false
}
func rewriteValuegeneric_OpLeq16(v *Value, config *Config) bool {
// match: (Leq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) <= int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end76b1c51f9b7cd7ee2f75b9f7057569de
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end76b1c51f9b7cd7ee2f75b9f7057569de
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) <= int16(d))
return true
}
- goto end76b1c51f9b7cd7ee2f75b9f7057569de
-end76b1c51f9b7cd7ee2f75b9f7057569de:
- ;
return false
}
func rewriteValuegeneric_OpLeq16U(v *Value, config *Config) bool {
// match: (Leq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto endf010fdf7f2c438ec18c33f493dd062aa
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto endf010fdf7f2c438ec18c33f493dd062aa
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint16(c) <= uint16(d))
return true
}
- goto endf010fdf7f2c438ec18c33f493dd062aa
-endf010fdf7f2c438ec18c33f493dd062aa:
- ;
return false
}
func rewriteValuegeneric_OpLeq32(v *Value, config *Config) bool {
// match: (Leq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) <= int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end6c7d61cfd188680bea8a5e23f08ca1de
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end6c7d61cfd188680bea8a5e23f08ca1de
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) <= int32(d))
return true
}
- goto end6c7d61cfd188680bea8a5e23f08ca1de
-end6c7d61cfd188680bea8a5e23f08ca1de:
- ;
return false
}
func rewriteValuegeneric_OpLeq32U(v *Value, config *Config) bool {
// match: (Leq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end4363555333511ee9b649b36f1a0ba34e
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end4363555333511ee9b649b36f1a0ba34e
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint32(c) <= uint32(d))
return true
}
- goto end4363555333511ee9b649b36f1a0ba34e
-end4363555333511ee9b649b36f1a0ba34e:
- ;
return false
}
func rewriteValuegeneric_OpLeq64(v *Value, config *Config) bool {
// match: (Leq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) <= int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto enddc865cd7ac2093abc7617bedbf371c22
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto enddc865cd7ac2093abc7617bedbf371c22
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) <= int64(d))
return true
}
- goto enddc865cd7ac2093abc7617bedbf371c22
-enddc865cd7ac2093abc7617bedbf371c22:
- ;
return false
}
func rewriteValuegeneric_OpLeq64U(v *Value, config *Config) bool {
// match: (Leq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end412eadb168738ba92f3f0705d4495305
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end412eadb168738ba92f3f0705d4495305
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint64(c) <= uint64(d))
return true
}
- goto end412eadb168738ba92f3f0705d4495305
-end412eadb168738ba92f3f0705d4495305:
- ;
return false
}
func rewriteValuegeneric_OpLeq8(v *Value, config *Config) bool {
// match: (Leq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) <= int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endb5a459da8e18c40abc0c7a20e71d0187
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endb5a459da8e18c40abc0c7a20e71d0187
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) <= int8(d))
return true
}
- goto endb5a459da8e18c40abc0c7a20e71d0187
-endb5a459da8e18c40abc0c7a20e71d0187:
- ;
return false
}
func rewriteValuegeneric_OpLeq8U(v *Value, config *Config) bool {
// match: (Leq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) <= uint8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endd6622d55fcdf3fa7b08e7511cd3b7d85
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endd6622d55fcdf3fa7b08e7511cd3b7d85
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint8(c) <= uint8(d))
return true
}
- goto endd6622d55fcdf3fa7b08e7511cd3b7d85
-endd6622d55fcdf3fa7b08e7511cd3b7d85:
- ;
return false
}
func rewriteValuegeneric_OpLess16(v *Value, config *Config) bool {
// match: (Less16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) < int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end0dc915d089f05e79589ebb5c498cc360
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end0dc915d089f05e79589ebb5c498cc360
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) < int16(d))
return true
}
- goto end0dc915d089f05e79589ebb5c498cc360
-end0dc915d089f05e79589ebb5c498cc360:
- ;
return false
}
func rewriteValuegeneric_OpLess16U(v *Value, config *Config) bool {
// match: (Less16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) < uint16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto endd2bb8249443788690946fc184631a00a
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto endd2bb8249443788690946fc184631a00a
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint16(c) < uint16(d))
return true
}
- goto endd2bb8249443788690946fc184631a00a
-endd2bb8249443788690946fc184631a00a:
- ;
return false
}
func rewriteValuegeneric_OpLess32(v *Value, config *Config) bool {
// match: (Less32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) < int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto endc86f65e499688809d414f03539bec5bf
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto endc86f65e499688809d414f03539bec5bf
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) < int32(d))
return true
}
- goto endc86f65e499688809d414f03539bec5bf
-endc86f65e499688809d414f03539bec5bf:
- ;
return false
}
func rewriteValuegeneric_OpLess32U(v *Value, config *Config) bool {
// match: (Less32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) < uint32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end2cc68b5247b1afb90a9d3923b28ff247
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end2cc68b5247b1afb90a9d3923b28ff247
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint32(c) < uint32(d))
return true
}
- goto end2cc68b5247b1afb90a9d3923b28ff247
-end2cc68b5247b1afb90a9d3923b28ff247:
- ;
return false
}
func rewriteValuegeneric_OpLess64(v *Value, config *Config) bool {
// match: (Less64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) < int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end505de73cd15125dbb59b05d8975d3128
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end505de73cd15125dbb59b05d8975d3128
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) < int64(d))
return true
}
- goto end505de73cd15125dbb59b05d8975d3128
-end505de73cd15125dbb59b05d8975d3128:
- ;
return false
}
func rewriteValuegeneric_OpLess64U(v *Value, config *Config) bool {
// match: (Less64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) < uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto endeb249ef36416cd1abf4f807026c059cd
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endeb249ef36416cd1abf4f807026c059cd
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint64(c) < uint64(d))
return true
}
- goto endeb249ef36416cd1abf4f807026c059cd
-endeb249ef36416cd1abf4f807026c059cd:
- ;
return false
}
func rewriteValuegeneric_OpLess8(v *Value, config *Config) bool {
// match: (Less8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) < int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endef134de03bc8537ac1f38d5eccff7673
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endef134de03bc8537ac1f38d5eccff7673
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) < int8(d))
return true
}
- goto endef134de03bc8537ac1f38d5eccff7673
-endef134de03bc8537ac1f38d5eccff7673:
- ;
return false
}
func rewriteValuegeneric_OpLess8U(v *Value, config *Config) bool {
// match: (Less8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) < uint8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end263ecdc279924bff8771dd1ac3f42222
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto end263ecdc279924bff8771dd1ac3f42222
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(uint8(c) < uint8(d))
return true
}
- goto end263ecdc279924bff8771dd1ac3f42222
-end263ecdc279924bff8771dd1ac3f42222:
- ;
return false
}
func rewriteValuegeneric_OpLoad(v *Value, config *Config) bool {
// match: (Load <t> _ _)
// cond: t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)
// result: (StructMake0)
- {
+ for {
t := v.Type
if !(t.IsStruct() && t.NumFields() == 0 && config.fe.CanSSA(t)) {
- goto end8d25f5c949948132921b6be29ede6bde
+ break
}
v.reset(OpStructMake0)
return true
}
- goto end8d25f5c949948132921b6be29ede6bde
-end8d25f5c949948132921b6be29ede6bde:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)
// result: (StructMake1 (Load <t.FieldType(0)> ptr mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsStruct() && t.NumFields() == 1 && config.fe.CanSSA(t)) {
- goto endfe908e5a8617dd39df2f9b2b92e93ae5
+ break
}
v.reset(OpStructMake1)
v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
v.AddArg(v0)
return true
}
- goto endfe908e5a8617dd39df2f9b2b92e93ae5
-endfe908e5a8617dd39df2f9b2b92e93ae5:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)
// result: (StructMake2 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsStruct() && t.NumFields() == 2 && config.fe.CanSSA(t)) {
- goto end20e20e64004b765012cfb80c575ef27b
+ break
}
v.reset(OpStructMake2)
v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
v.AddArg(v1)
return true
}
- goto end20e20e64004b765012cfb80c575ef27b
-end20e20e64004b765012cfb80c575ef27b:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)
// result: (StructMake3 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsStruct() && t.NumFields() == 3 && config.fe.CanSSA(t)) {
- goto ende612bf71067ed67541735cdc8b5a3288
+ break
}
v.reset(OpStructMake3)
v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
v.AddArg(v3)
return true
}
- goto ende612bf71067ed67541735cdc8b5a3288
-ende612bf71067ed67541735cdc8b5a3288:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)
// result: (StructMake4 (Load <t.FieldType(0)> ptr mem) (Load <t.FieldType(1)> (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] ptr) mem) (Load <t.FieldType(2)> (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] ptr) mem) (Load <t.FieldType(3)> (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsStruct() && t.NumFields() == 4 && config.fe.CanSSA(t)) {
- goto end46c66c64d9030f2cc9a7a767f67953d1
+ break
}
v.reset(OpStructMake4)
v0 := b.NewValue0(v.Line, OpLoad, t.FieldType(0))
v.AddArg(v5)
return true
}
- goto end46c66c64d9030f2cc9a7a767f67953d1
-end46c66c64d9030f2cc9a7a767f67953d1:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 8
// result: (ComplexMake (Load <config.fe.TypeFloat32()> ptr mem) (Load <config.fe.TypeFloat32()> (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] ptr) mem) )
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsComplex() && t.Size() == 8) {
- goto end665854b31b828893d90b36bb462ff381
+ break
}
v.reset(OpComplexMake)
v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat32())
v.AddArg(v1)
return true
}
- goto end665854b31b828893d90b36bb462ff381
-end665854b31b828893d90b36bb462ff381:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsComplex() && t.Size() == 16
// result: (ComplexMake (Load <config.fe.TypeFloat64()> ptr mem) (Load <config.fe.TypeFloat64()> (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] ptr) mem) )
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsComplex() && t.Size() == 16) {
- goto end1b106f89e0e3e26c613b957a7c98d8ad
+ break
}
v.reset(OpComplexMake)
v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeFloat64())
v.AddArg(v1)
return true
}
- goto end1b106f89e0e3e26c613b957a7c98d8ad
-end1b106f89e0e3e26c613b957a7c98d8ad:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsString()
// result: (StringMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsString()) {
- goto enddd15a6f3d53a6ce7a19d4e181dd1c13a
+ break
}
v.reset(OpStringMake)
v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto enddd15a6f3d53a6ce7a19d4e181dd1c13a
-enddd15a6f3d53a6ce7a19d4e181dd1c13a:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsSlice()
// result: (SliceMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] ptr) mem) (Load <config.fe.TypeInt()> (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsSlice()) {
- goto end65e8b0055aa7491b9b6066d9fe1b2c13
+ break
}
v.reset(OpSliceMake)
v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
v.AddArg(v3)
return true
}
- goto end65e8b0055aa7491b9b6066d9fe1b2c13
-end65e8b0055aa7491b9b6066d9fe1b2c13:
- ;
// match: (Load <t> ptr mem)
// cond: t.IsInterface()
// result: (IMake (Load <config.fe.TypeBytePtr()> ptr mem) (Load <config.fe.TypeBytePtr()> (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] ptr) mem))
- {
+ for {
t := v.Type
ptr := v.Args[0]
mem := v.Args[1]
if !(t.IsInterface()) {
- goto end12671c83ebe3ccbc8e53383765ee7675
+ break
}
v.reset(OpIMake)
v0 := b.NewValue0(v.Line, OpLoad, config.fe.TypeBytePtr())
v.AddArg(v1)
return true
}
- goto end12671c83ebe3ccbc8e53383765ee7675
-end12671c83ebe3ccbc8e53383765ee7675:
- ;
return false
}
func rewriteValuegeneric_OpLsh16x16(v *Value, config *Config) bool {
// match: (Lsh16x16 <t> x (Const16 [c]))
// cond:
// result: (Lsh16x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end2f5aa78b30ebd2471e8d03a307923b06
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh16x64)
v.AddArg(v0)
return true
}
- goto end2f5aa78b30ebd2471e8d03a307923b06
-end2f5aa78b30ebd2471e8d03a307923b06:
- ;
return false
}
func rewriteValuegeneric_OpLsh16x32(v *Value, config *Config) bool {
// match: (Lsh16x32 <t> x (Const32 [c]))
// cond:
// result: (Lsh16x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto endedeb000c8c97090261a47f08a2ff17e4
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh16x64)
v.AddArg(v0)
return true
}
- goto endedeb000c8c97090261a47f08a2ff17e4
-endedeb000c8c97090261a47f08a2ff17e4:
- ;
return false
}
func rewriteValuegeneric_OpLsh16x64(v *Value, config *Config) bool {
// match: (Lsh16x64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(int16(c) << uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto endc9f0d91f3da4bdd46a634a62549810e0
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endc9f0d91f3da4bdd46a634a62549810e0
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = int64(int16(c) << uint64(d))
return true
}
- goto endc9f0d91f3da4bdd46a634a62549810e0
-endc9f0d91f3da4bdd46a634a62549810e0:
- ;
// match: (Lsh16x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end7ecc343739fab9b50a0bdff6e9d121e6
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end7ecc343739fab9b50a0bdff6e9d121e6
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end7ecc343739fab9b50a0bdff6e9d121e6
-end7ecc343739fab9b50a0bdff6e9d121e6:
- ;
// match: (Lsh16x64 _ (Const64 [c]))
// cond: uint64(c) >= 16
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto end1d2c74d359df9d89b16c4f658a231dfe
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 16) {
- goto end1d2c74d359df9d89b16c4f658a231dfe
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto end1d2c74d359df9d89b16c4f658a231dfe
-end1d2c74d359df9d89b16c4f658a231dfe:
- ;
// match: (Lsh16x64 <t> (Lsh16x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Lsh16x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpLsh16x64 {
- goto end26a91e42735a02a30e94a998f54372dd
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end26a91e42735a02a30e94a998f54372dd
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end26a91e42735a02a30e94a998f54372dd
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end26a91e42735a02a30e94a998f54372dd
+ break
}
v.reset(OpLsh16x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end26a91e42735a02a30e94a998f54372dd
-end26a91e42735a02a30e94a998f54372dd:
- ;
return false
}
func rewriteValuegeneric_OpLsh16x8(v *Value, config *Config) bool {
// match: (Lsh16x8 <t> x (Const8 [c]))
// cond:
// result: (Lsh16x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto endce2401b8a6c6190fe81d77e2d562a10c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh16x64)
v.AddArg(v0)
return true
}
- goto endce2401b8a6c6190fe81d77e2d562a10c
-endce2401b8a6c6190fe81d77e2d562a10c:
- ;
return false
}
func rewriteValuegeneric_OpLsh32x16(v *Value, config *Config) bool {
// match: (Lsh32x16 <t> x (Const16 [c]))
// cond:
// result: (Lsh32x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end7205eb3e315971143ac5584d07045570
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh32x64)
v.AddArg(v0)
return true
}
- goto end7205eb3e315971143ac5584d07045570
-end7205eb3e315971143ac5584d07045570:
- ;
return false
}
func rewriteValuegeneric_OpLsh32x32(v *Value, config *Config) bool {
// match: (Lsh32x32 <t> x (Const32 [c]))
// cond:
// result: (Lsh32x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto endc1a330b287199c80228e665a53881298
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh32x64)
v.AddArg(v0)
return true
}
- goto endc1a330b287199c80228e665a53881298
-endc1a330b287199c80228e665a53881298:
- ;
return false
}
func rewriteValuegeneric_OpLsh32x64(v *Value, config *Config) bool {
// match: (Lsh32x64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(int32(c) << uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end5896bd9a3fe78f1e1712563642d33254
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end5896bd9a3fe78f1e1712563642d33254
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = int64(int32(c) << uint64(d))
return true
}
- goto end5896bd9a3fe78f1e1712563642d33254
-end5896bd9a3fe78f1e1712563642d33254:
- ;
// match: (Lsh32x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto endd9ce9639a91b11e601823be3d4d6c209
+ break
}
if v.Args[1].AuxInt != 0 {
- goto endd9ce9639a91b11e601823be3d4d6c209
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endd9ce9639a91b11e601823be3d4d6c209
-endd9ce9639a91b11e601823be3d4d6c209:
- ;
// match: (Lsh32x64 _ (Const64 [c]))
// cond: uint64(c) >= 32
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto end81247a2423f489be15859d3930738fdf
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 32) {
- goto end81247a2423f489be15859d3930738fdf
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto end81247a2423f489be15859d3930738fdf
-end81247a2423f489be15859d3930738fdf:
- ;
// match: (Lsh32x64 <t> (Lsh32x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Lsh32x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpLsh32x64 {
- goto endf96a7c9571797fe61a5b63a4923d7e6e
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto endf96a7c9571797fe61a5b63a4923d7e6e
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endf96a7c9571797fe61a5b63a4923d7e6e
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto endf96a7c9571797fe61a5b63a4923d7e6e
+ break
}
v.reset(OpLsh32x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto endf96a7c9571797fe61a5b63a4923d7e6e
-endf96a7c9571797fe61a5b63a4923d7e6e:
- ;
return false
}
func rewriteValuegeneric_OpLsh32x8(v *Value, config *Config) bool {
// match: (Lsh32x8 <t> x (Const8 [c]))
// cond:
// result: (Lsh32x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end1759d7c25a5bcda288e34d1d197c0b8f
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh32x64)
v.AddArg(v0)
return true
}
- goto end1759d7c25a5bcda288e34d1d197c0b8f
-end1759d7c25a5bcda288e34d1d197c0b8f:
- ;
return false
}
func rewriteValuegeneric_OpLsh64x16(v *Value, config *Config) bool {
// match: (Lsh64x16 <t> x (Const16 [c]))
// cond:
// result: (Lsh64x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto enda649fbb5e14490c9eea9616550a76b5c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh64x64)
v.AddArg(v0)
return true
}
- goto enda649fbb5e14490c9eea9616550a76b5c
-enda649fbb5e14490c9eea9616550a76b5c:
- ;
return false
}
func rewriteValuegeneric_OpLsh64x32(v *Value, config *Config) bool {
// match: (Lsh64x32 <t> x (Const32 [c]))
// cond:
// result: (Lsh64x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end40069675cde851a63cce81b1b02751f9
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh64x64)
v.AddArg(v0)
return true
}
- goto end40069675cde851a63cce81b1b02751f9
-end40069675cde851a63cce81b1b02751f9:
- ;
return false
}
func rewriteValuegeneric_OpLsh64x64(v *Value, config *Config) bool {
// match: (Lsh64x64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c << uint64(d)])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end9c157a23e021f659f1568566435ed57b
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end9c157a23e021f659f1568566435ed57b
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = c << uint64(d)
return true
}
- goto end9c157a23e021f659f1568566435ed57b
-end9c157a23e021f659f1568566435ed57b:
- ;
// match: (Lsh64x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end9f18ca0556dbb4b50fe888273fab20ca
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end9f18ca0556dbb4b50fe888273fab20ca
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end9f18ca0556dbb4b50fe888273fab20ca
-end9f18ca0556dbb4b50fe888273fab20ca:
- ;
// match: (Lsh64x64 _ (Const64 [c]))
// cond: uint64(c) >= 64
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto end33da2e0ce5ca3e0554564477ef422402
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 64) {
- goto end33da2e0ce5ca3e0554564477ef422402
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto end33da2e0ce5ca3e0554564477ef422402
-end33da2e0ce5ca3e0554564477ef422402:
- ;
// match: (Lsh64x64 <t> (Lsh64x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Lsh64x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpLsh64x64 {
- goto end001c62ee580a700ec7b07ccaa3740ac2
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end001c62ee580a700ec7b07ccaa3740ac2
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end001c62ee580a700ec7b07ccaa3740ac2
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end001c62ee580a700ec7b07ccaa3740ac2
+ break
}
v.reset(OpLsh64x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end001c62ee580a700ec7b07ccaa3740ac2
-end001c62ee580a700ec7b07ccaa3740ac2:
- ;
return false
}
func rewriteValuegeneric_OpLsh64x8(v *Value, config *Config) bool {
// match: (Lsh64x8 <t> x (Const8 [c]))
// cond:
// result: (Lsh64x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end4d9224069abdade8e405df343938d932
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh64x64)
v.AddArg(v0)
return true
}
- goto end4d9224069abdade8e405df343938d932
-end4d9224069abdade8e405df343938d932:
- ;
return false
}
func rewriteValuegeneric_OpLsh8x16(v *Value, config *Config) bool {
// match: (Lsh8x16 <t> x (Const16 [c]))
// cond:
// result: (Lsh8x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end0ad4a82e2eb4c7ca7407d79ec3aa5142
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh8x64)
v.AddArg(v0)
return true
}
- goto end0ad4a82e2eb4c7ca7407d79ec3aa5142
-end0ad4a82e2eb4c7ca7407d79ec3aa5142:
- ;
return false
}
func rewriteValuegeneric_OpLsh8x32(v *Value, config *Config) bool {
// match: (Lsh8x32 <t> x (Const32 [c]))
// cond:
// result: (Lsh8x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto enddaacda113ecc79fe0621fd22ebc548dd
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh8x64)
v.AddArg(v0)
return true
}
- goto enddaacda113ecc79fe0621fd22ebc548dd
-enddaacda113ecc79fe0621fd22ebc548dd:
- ;
return false
}
func rewriteValuegeneric_OpLsh8x64(v *Value, config *Config) bool {
// match: (Lsh8x64 (Const8 [c]) (Const64 [d]))
// cond:
// result: (Const8 [int64(int8(c) << uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endbc3297ea9642b97eb71f0a9735048d7b
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endbc3297ea9642b97eb71f0a9735048d7b
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = int64(int8(c) << uint64(d))
return true
}
- goto endbc3297ea9642b97eb71f0a9735048d7b
-endbc3297ea9642b97eb71f0a9735048d7b:
- ;
// match: (Lsh8x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end715f3db41cccf963e25a20c33f618a04
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end715f3db41cccf963e25a20c33f618a04
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end715f3db41cccf963e25a20c33f618a04
-end715f3db41cccf963e25a20c33f618a04:
- ;
// match: (Lsh8x64 _ (Const64 [c]))
// cond: uint64(c) >= 8
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto endb6749df4d0cdc0cd9acc627187d73488
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 8) {
- goto endb6749df4d0cdc0cd9acc627187d73488
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto endb6749df4d0cdc0cd9acc627187d73488
-endb6749df4d0cdc0cd9acc627187d73488:
- ;
// match: (Lsh8x64 <t> (Lsh8x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Lsh8x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpLsh8x64 {
- goto end73a4878b6bbd21c9e22fb99226ef947e
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end73a4878b6bbd21c9e22fb99226ef947e
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end73a4878b6bbd21c9e22fb99226ef947e
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end73a4878b6bbd21c9e22fb99226ef947e
+ break
}
v.reset(OpLsh8x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end73a4878b6bbd21c9e22fb99226ef947e
-end73a4878b6bbd21c9e22fb99226ef947e:
- ;
return false
}
func rewriteValuegeneric_OpLsh8x8(v *Value, config *Config) bool {
// match: (Lsh8x8 <t> x (Const8 [c]))
// cond:
// result: (Lsh8x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end8b770597435467b0c96014624d522b33
+ break
}
c := v.Args[1].AuxInt
v.reset(OpLsh8x64)
v.AddArg(v0)
return true
}
- goto end8b770597435467b0c96014624d522b33
-end8b770597435467b0c96014624d522b33:
- ;
return false
}
func rewriteValuegeneric_OpMul16(v *Value, config *Config) bool {
// match: (Mul16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [c*d])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto ende8dd468add3015aea24531cf3c89ccb7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto ende8dd468add3015aea24531cf3c89ccb7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = c * d
return true
}
- goto ende8dd468add3015aea24531cf3c89ccb7
-ende8dd468add3015aea24531cf3c89ccb7:
- ;
return false
}
func rewriteValuegeneric_OpMul32(v *Value, config *Config) bool {
// match: (Mul32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [c*d])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end60b4523099fa7b55e2e872e05bd497a7
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end60b4523099fa7b55e2e872e05bd497a7
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = c * d
return true
}
- goto end60b4523099fa7b55e2e872e05bd497a7
-end60b4523099fa7b55e2e872e05bd497a7:
- ;
return false
}
func rewriteValuegeneric_OpMul64(v *Value, config *Config) bool {
// match: (Mul64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c*d])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end7aea1048b5d1230974b97f17238380ae
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end7aea1048b5d1230974b97f17238380ae
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = c * d
return true
}
- goto end7aea1048b5d1230974b97f17238380ae
-end7aea1048b5d1230974b97f17238380ae:
- ;
return false
}
func rewriteValuegeneric_OpMul8(v *Value, config *Config) bool {
// match: (Mul8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [c*d])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end2f1952fd654c4a62ff00511041728809
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto end2f1952fd654c4a62ff00511041728809
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = c * d
return true
}
- goto end2f1952fd654c4a62ff00511041728809
-end2f1952fd654c4a62ff00511041728809:
- ;
return false
}
func rewriteValuegeneric_OpNeq16(v *Value, config *Config) bool {
// match: (Neq16 x x)
// cond:
// result: (ConstBool [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto ende76a50b524aeb16c7aeccf5f5cc60c06
+ break
}
v.reset(OpConstBool)
v.AuxInt = 0
return true
}
- goto ende76a50b524aeb16c7aeccf5f5cc60c06
-ende76a50b524aeb16c7aeccf5f5cc60c06:
- ;
// match: (Neq16 (Const16 <t> [c]) (Add16 (Const16 <t> [d]) x))
// cond:
// result: (Neq16 (Const16 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end552011bd97e6f92ebc2672aa1843eadd
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd16 {
- goto end552011bd97e6f92ebc2672aa1843eadd
+ break
}
if v.Args[1].Args[0].Op != OpConst16 {
- goto end552011bd97e6f92ebc2672aa1843eadd
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto end552011bd97e6f92ebc2672aa1843eadd
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto end552011bd97e6f92ebc2672aa1843eadd
-end552011bd97e6f92ebc2672aa1843eadd:
- ;
// match: (Neq16 x (Const16 <t> [c]))
// cond: x.Op != OpConst16
// result: (Neq16 (Const16 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end0e45958f29e87997f632248aa9ee97e0
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst16) {
- goto end0e45958f29e87997f632248aa9ee97e0
+ break
}
v.reset(OpNeq16)
v0 := b.NewValue0(v.Line, OpConst16, t)
v.AddArg(x)
return true
}
- goto end0e45958f29e87997f632248aa9ee97e0
-end0e45958f29e87997f632248aa9ee97e0:
- ;
// match: (Neq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(int16(c) != int16(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end6302c9b645bb191982d28c2f846904d6
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end6302c9b645bb191982d28c2f846904d6
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int16(c) != int16(d))
return true
}
- goto end6302c9b645bb191982d28c2f846904d6
-end6302c9b645bb191982d28c2f846904d6:
- ;
return false
}
func rewriteValuegeneric_OpNeq32(v *Value, config *Config) bool {
// match: (Neq32 x x)
// cond:
// result: (ConstBool [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end3713a608cffd29b40ff7c3b3f2585cbb
+ break
}
v.reset(OpConstBool)
v.AuxInt = 0
return true
}
- goto end3713a608cffd29b40ff7c3b3f2585cbb
-end3713a608cffd29b40ff7c3b3f2585cbb:
- ;
// match: (Neq32 (Const32 <t> [c]) (Add32 (Const32 <t> [d]) x))
// cond:
// result: (Neq32 (Const32 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end93fc3b4a3639b965b414891111b16245
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd32 {
- goto end93fc3b4a3639b965b414891111b16245
+ break
}
if v.Args[1].Args[0].Op != OpConst32 {
- goto end93fc3b4a3639b965b414891111b16245
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto end93fc3b4a3639b965b414891111b16245
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto end93fc3b4a3639b965b414891111b16245
-end93fc3b4a3639b965b414891111b16245:
- ;
// match: (Neq32 x (Const32 <t> [c]))
// cond: x.Op != OpConst32
// result: (Neq32 (Const32 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end5376f9ab90e282450f49011d0e0ce236
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst32) {
- goto end5376f9ab90e282450f49011d0e0ce236
+ break
}
v.reset(OpNeq32)
v0 := b.NewValue0(v.Line, OpConst32, t)
v.AddArg(x)
return true
}
- goto end5376f9ab90e282450f49011d0e0ce236
-end5376f9ab90e282450f49011d0e0ce236:
- ;
// match: (Neq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(int32(c) != int32(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto endf9f3d0814854d2d0879d331e9bdfcae2
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto endf9f3d0814854d2d0879d331e9bdfcae2
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int32(c) != int32(d))
return true
}
- goto endf9f3d0814854d2d0879d331e9bdfcae2
-endf9f3d0814854d2d0879d331e9bdfcae2:
- ;
return false
}
func rewriteValuegeneric_OpNeq64(v *Value, config *Config) bool {
// match: (Neq64 x x)
// cond:
// result: (ConstBool [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end3601ad382705ea12b79d2008c1e5725c
+ break
}
v.reset(OpConstBool)
v.AuxInt = 0
return true
}
- goto end3601ad382705ea12b79d2008c1e5725c
-end3601ad382705ea12b79d2008c1e5725c:
- ;
// match: (Neq64 (Const64 <t> [c]) (Add64 (Const64 <t> [d]) x))
// cond:
// result: (Neq64 (Const64 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto enda3d39cad13a557a2aa6d086f43596c1b
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd64 {
- goto enda3d39cad13a557a2aa6d086f43596c1b
+ break
}
if v.Args[1].Args[0].Op != OpConst64 {
- goto enda3d39cad13a557a2aa6d086f43596c1b
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto enda3d39cad13a557a2aa6d086f43596c1b
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto enda3d39cad13a557a2aa6d086f43596c1b
-enda3d39cad13a557a2aa6d086f43596c1b:
- ;
// match: (Neq64 x (Const64 <t> [c]))
// cond: x.Op != OpConst64
// result: (Neq64 (Const64 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end0936a57de20373ca6cacb9506ddde708
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst64) {
- goto end0936a57de20373ca6cacb9506ddde708
+ break
}
v.reset(OpNeq64)
v0 := b.NewValue0(v.Line, OpConst64, t)
v.AddArg(x)
return true
}
- goto end0936a57de20373ca6cacb9506ddde708
-end0936a57de20373ca6cacb9506ddde708:
- ;
// match: (Neq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(int64(c) != int64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto endf07433ecd3c150b1b75e943aa44a7203
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endf07433ecd3c150b1b75e943aa44a7203
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int64(c) != int64(d))
return true
}
- goto endf07433ecd3c150b1b75e943aa44a7203
-endf07433ecd3c150b1b75e943aa44a7203:
- ;
return false
}
func rewriteValuegeneric_OpNeq8(v *Value, config *Config) bool {
// match: (Neq8 x x)
// cond:
// result: (ConstBool [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end09a0deaf3c42627d0d2d3efa96e30745
+ break
}
v.reset(OpConstBool)
v.AuxInt = 0
return true
}
- goto end09a0deaf3c42627d0d2d3efa96e30745
-end09a0deaf3c42627d0d2d3efa96e30745:
- ;
// match: (Neq8 (Const8 <t> [c]) (Add8 (Const8 <t> [d]) x))
// cond:
// result: (Neq8 (Const8 <t> [c-d]) x)
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endc8f853c610c460c887cbfdca958e3691
+ break
}
t := v.Args[0].Type
c := v.Args[0].AuxInt
if v.Args[1].Op != OpAdd8 {
- goto endc8f853c610c460c887cbfdca958e3691
+ break
}
if v.Args[1].Args[0].Op != OpConst8 {
- goto endc8f853c610c460c887cbfdca958e3691
+ break
}
if v.Args[1].Args[0].Type != v.Args[0].Type {
- goto endc8f853c610c460c887cbfdca958e3691
+ break
}
d := v.Args[1].Args[0].AuxInt
x := v.Args[1].Args[1]
v.AddArg(x)
return true
}
- goto endc8f853c610c460c887cbfdca958e3691
-endc8f853c610c460c887cbfdca958e3691:
- ;
// match: (Neq8 x (Const8 <t> [c]))
// cond: x.Op != OpConst8
// result: (Neq8 (Const8 <t> [c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end04dc0ae2b08cf0447b50e5b8ef469252
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst8) {
- goto end04dc0ae2b08cf0447b50e5b8ef469252
+ break
}
v.reset(OpNeq8)
v0 := b.NewValue0(v.Line, OpConst8, t)
v.AddArg(x)
return true
}
- goto end04dc0ae2b08cf0447b50e5b8ef469252
-end04dc0ae2b08cf0447b50e5b8ef469252:
- ;
// match: (Neq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(int8(c) != int8(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConstBool)
v.AuxInt = b2i(int8(c) != int8(d))
return true
}
- goto end72ebdaf2de9b3aa57cf0cb8e068b5f9c
-end72ebdaf2de9b3aa57cf0cb8e068b5f9c:
- ;
return false
}
func rewriteValuegeneric_OpNeqInter(v *Value, config *Config) bool {
// match: (NeqInter x y)
// cond:
// result: (NeqPtr (ITab x) (ITab y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpNeqPtr)
v.AddArg(v1)
return true
}
- goto end17b2333bf57e9fe81a671be02f9c4c14
-end17b2333bf57e9fe81a671be02f9c4c14:
- ;
return false
}
func rewriteValuegeneric_OpNeqPtr(v *Value, config *Config) bool {
// match: (NeqPtr p (ConstNil))
// cond:
// result: (IsNonNil p)
- {
+ for {
p := v.Args[0]
if v.Args[1].Op != OpConstNil {
- goto endba798520b4d41172b110347158c44791
+ break
}
v.reset(OpIsNonNil)
v.AddArg(p)
return true
}
- goto endba798520b4d41172b110347158c44791
-endba798520b4d41172b110347158c44791:
- ;
// match: (NeqPtr (ConstNil) p)
// cond:
// result: (IsNonNil p)
- {
+ for {
if v.Args[0].Op != OpConstNil {
- goto enddd95e9c3606d9fd48034f1a703561e45
+ break
}
p := v.Args[1]
v.reset(OpIsNonNil)
v.AddArg(p)
return true
}
- goto enddd95e9c3606d9fd48034f1a703561e45
-enddd95e9c3606d9fd48034f1a703561e45:
- ;
return false
}
func rewriteValuegeneric_OpNeqSlice(v *Value, config *Config) bool {
// match: (NeqSlice x y)
// cond:
// result: (NeqPtr (SlicePtr x) (SlicePtr y))
- {
+ for {
x := v.Args[0]
y := v.Args[1]
v.reset(OpNeqPtr)
v.AddArg(v1)
return true
}
- goto endc6bc83c506e491236ca66ea1081231a2
-endc6bc83c506e491236ca66ea1081231a2:
- ;
return false
}
func rewriteValuegeneric_OpOr16(v *Value, config *Config) bool {
// match: (Or16 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end47a2f25fd31a76807aced3e2b126acdc
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end47a2f25fd31a76807aced3e2b126acdc
-end47a2f25fd31a76807aced3e2b126acdc:
- ;
return false
}
func rewriteValuegeneric_OpOr32(v *Value, config *Config) bool {
// match: (Or32 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end231e283e568e90bd9a3e6a4fa328c8a4
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end231e283e568e90bd9a3e6a4fa328c8a4
-end231e283e568e90bd9a3e6a4fa328c8a4:
- ;
return false
}
func rewriteValuegeneric_OpOr64(v *Value, config *Config) bool {
// match: (Or64 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end6b0efc212016dc97d0e3939db04c81d9
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end6b0efc212016dc97d0e3939db04c81d9
-end6b0efc212016dc97d0e3939db04c81d9:
- ;
return false
}
func rewriteValuegeneric_OpOr8(v *Value, config *Config) bool {
// match: (Or8 x x)
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end05295dbfafd6869af79b4daee9fda000
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end05295dbfafd6869af79b4daee9fda000
-end05295dbfafd6869af79b4daee9fda000:
- ;
return false
}
func rewriteValuegeneric_OpPtrIndex(v *Value, config *Config) bool {
// match: (PtrIndex <t> ptr idx)
// cond: config.PtrSize == 4
// result: (AddPtr ptr (Mul32 <config.fe.TypeInt()> idx (Const32 <config.fe.TypeInt()> [t.Elem().Size()])))
- {
+ for {
t := v.Type
ptr := v.Args[0]
idx := v.Args[1]
if !(config.PtrSize == 4) {
- goto endd902622aaa1e7545b5a2a0c08b47d287
+ break
}
v.reset(OpAddPtr)
v.AddArg(ptr)
v.AddArg(v0)
return true
}
- goto endd902622aaa1e7545b5a2a0c08b47d287
-endd902622aaa1e7545b5a2a0c08b47d287:
- ;
// match: (PtrIndex <t> ptr idx)
// cond: config.PtrSize == 8
// result: (AddPtr ptr (Mul64 <config.fe.TypeInt()> idx (Const64 <config.fe.TypeInt()> [t.Elem().Size()])))
- {
+ for {
t := v.Type
ptr := v.Args[0]
idx := v.Args[1]
if !(config.PtrSize == 8) {
- goto end47a5f1d1b158914fa383de024bbe3b08
+ break
}
v.reset(OpAddPtr)
v.AddArg(ptr)
v.AddArg(v0)
return true
}
- goto end47a5f1d1b158914fa383de024bbe3b08
-end47a5f1d1b158914fa383de024bbe3b08:
- ;
return false
}
func rewriteValuegeneric_OpRsh16Ux16(v *Value, config *Config) bool {
// match: (Rsh16Ux16 <t> x (Const16 [c]))
// cond:
// result: (Rsh16Ux64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto endd981df40f353104ef828d13ad4ccdf02
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16Ux64)
v.AddArg(v0)
return true
}
- goto endd981df40f353104ef828d13ad4ccdf02
-endd981df40f353104ef828d13ad4ccdf02:
- ;
return false
}
func rewriteValuegeneric_OpRsh16Ux32(v *Value, config *Config) bool {
// match: (Rsh16Ux32 <t> x (Const32 [c]))
// cond:
// result: (Rsh16Ux64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto ende0be9ee562725206dcf96d3e5750b5ea
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16Ux64)
v.AddArg(v0)
return true
}
- goto ende0be9ee562725206dcf96d3e5750b5ea
-ende0be9ee562725206dcf96d3e5750b5ea:
- ;
return false
}
func rewriteValuegeneric_OpRsh16Ux64(v *Value, config *Config) bool {
// match: (Rsh16Ux64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(uint16(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto ended17f40375fb44bcbaf2d87161c5ed3c
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto ended17f40375fb44bcbaf2d87161c5ed3c
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = int64(uint16(c) >> uint64(d))
return true
}
- goto ended17f40375fb44bcbaf2d87161c5ed3c
-ended17f40375fb44bcbaf2d87161c5ed3c:
- ;
// match: (Rsh16Ux64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end752d1b5a60f87afa7e40febbf1bce309
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end752d1b5a60f87afa7e40febbf1bce309
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end752d1b5a60f87afa7e40febbf1bce309
-end752d1b5a60f87afa7e40febbf1bce309:
- ;
// match: (Rsh16Ux64 _ (Const64 [c]))
// cond: uint64(c) >= 16
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto endca5c7ae2e51f2ae32486c2b1a3033b77
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 16) {
- goto endca5c7ae2e51f2ae32486c2b1a3033b77
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto endca5c7ae2e51f2ae32486c2b1a3033b77
-endca5c7ae2e51f2ae32486c2b1a3033b77:
- ;
// match: (Rsh16Ux64 <t> (Rsh16Ux64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh16Ux64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh16Ux64 {
- goto end56f2c0034c9fbe651abb36fb640af465
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end56f2c0034c9fbe651abb36fb640af465
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end56f2c0034c9fbe651abb36fb640af465
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end56f2c0034c9fbe651abb36fb640af465
+ break
}
v.reset(OpRsh16Ux64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end56f2c0034c9fbe651abb36fb640af465
-end56f2c0034c9fbe651abb36fb640af465:
- ;
return false
}
func rewriteValuegeneric_OpRsh16Ux8(v *Value, config *Config) bool {
// match: (Rsh16Ux8 <t> x (Const8 [c]))
// cond:
// result: (Rsh16Ux64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end20d4667094c32c71bac4e0805dab85c9
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16Ux64)
v.AddArg(v0)
return true
}
- goto end20d4667094c32c71bac4e0805dab85c9
-end20d4667094c32c71bac4e0805dab85c9:
- ;
return false
}
func rewriteValuegeneric_OpRsh16x16(v *Value, config *Config) bool {
// match: (Rsh16x16 <t> x (Const16 [c]))
// cond:
// result: (Rsh16x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end1b501c7ae2fe58ad3a88b467f2d95389
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16x64)
v.AddArg(v0)
return true
}
- goto end1b501c7ae2fe58ad3a88b467f2d95389
-end1b501c7ae2fe58ad3a88b467f2d95389:
- ;
return false
}
func rewriteValuegeneric_OpRsh16x32(v *Value, config *Config) bool {
// match: (Rsh16x32 <t> x (Const32 [c]))
// cond:
// result: (Rsh16x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end4d3a41113d2d0b09924bf5759ca49cab
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16x64)
v.AddArg(v0)
return true
}
- goto end4d3a41113d2d0b09924bf5759ca49cab
-end4d3a41113d2d0b09924bf5759ca49cab:
- ;
return false
}
func rewriteValuegeneric_OpRsh16x64(v *Value, config *Config) bool {
// match: (Rsh16x64 (Const16 [c]) (Const64 [d]))
// cond:
// result: (Const16 [int64(int16(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end8f05fede35a3d2f687fcd4a5829a25ad
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end8f05fede35a3d2f687fcd4a5829a25ad
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = int64(int16(c) >> uint64(d))
return true
}
- goto end8f05fede35a3d2f687fcd4a5829a25ad
-end8f05fede35a3d2f687fcd4a5829a25ad:
- ;
// match: (Rsh16x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end750fafe01fcc689d953101d53efc19ab
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end750fafe01fcc689d953101d53efc19ab
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end750fafe01fcc689d953101d53efc19ab
-end750fafe01fcc689d953101d53efc19ab:
- ;
// match: (Rsh16x64 <t> (Rsh16x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh16x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh16x64 {
- goto endf425eff9e05aad27194af957e3383c76
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto endf425eff9e05aad27194af957e3383c76
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endf425eff9e05aad27194af957e3383c76
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto endf425eff9e05aad27194af957e3383c76
+ break
}
v.reset(OpRsh16x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto endf425eff9e05aad27194af957e3383c76
-endf425eff9e05aad27194af957e3383c76:
- ;
return false
}
func rewriteValuegeneric_OpRsh16x8(v *Value, config *Config) bool {
// match: (Rsh16x8 <t> x (Const8 [c]))
// cond:
// result: (Rsh16x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end0b5e274d62a3ae8df9f4089756c6a9d4
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh16x64)
v.AddArg(v0)
return true
}
- goto end0b5e274d62a3ae8df9f4089756c6a9d4
-end0b5e274d62a3ae8df9f4089756c6a9d4:
- ;
return false
}
func rewriteValuegeneric_OpRsh32Ux16(v *Value, config *Config) bool {
// match: (Rsh32Ux16 <t> x (Const16 [c]))
// cond:
// result: (Rsh32Ux64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32Ux64)
v.AddArg(v0)
return true
}
- goto end8d8f9f3e2e1f7a5e9a186fb792fc40a8
-end8d8f9f3e2e1f7a5e9a186fb792fc40a8:
- ;
return false
}
func rewriteValuegeneric_OpRsh32Ux32(v *Value, config *Config) bool {
// match: (Rsh32Ux32 <t> x (Const32 [c]))
// cond:
// result: (Rsh32Ux64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto endd23d060f74e00f34cc967b6fb9a4d320
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32Ux64)
v.AddArg(v0)
return true
}
- goto endd23d060f74e00f34cc967b6fb9a4d320
-endd23d060f74e00f34cc967b6fb9a4d320:
- ;
return false
}
func rewriteValuegeneric_OpRsh32Ux64(v *Value, config *Config) bool {
// match: (Rsh32Ux64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(uint32(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto enda101e6b765d7ecffd9b7410c9dc3be82
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto enda101e6b765d7ecffd9b7410c9dc3be82
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = int64(uint32(c) >> uint64(d))
return true
}
- goto enda101e6b765d7ecffd9b7410c9dc3be82
-enda101e6b765d7ecffd9b7410c9dc3be82:
- ;
// match: (Rsh32Ux64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end162e4e182a665d4e6f0d85fe131e7288
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end162e4e182a665d4e6f0d85fe131e7288
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end162e4e182a665d4e6f0d85fe131e7288
-end162e4e182a665d4e6f0d85fe131e7288:
- ;
// match: (Rsh32Ux64 _ (Const64 [c]))
// cond: uint64(c) >= 32
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto endca322c370839b4264b219ee042a6ab33
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 32) {
- goto endca322c370839b4264b219ee042a6ab33
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto endca322c370839b4264b219ee042a6ab33
-endca322c370839b4264b219ee042a6ab33:
- ;
// match: (Rsh32Ux64 <t> (Rsh32Ux64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh32Ux64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh32Ux64 {
- goto end2e502d68a32663142684194adbe6c297
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end2e502d68a32663142684194adbe6c297
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end2e502d68a32663142684194adbe6c297
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end2e502d68a32663142684194adbe6c297
+ break
}
v.reset(OpRsh32Ux64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end2e502d68a32663142684194adbe6c297
-end2e502d68a32663142684194adbe6c297:
- ;
return false
}
func rewriteValuegeneric_OpRsh32Ux8(v *Value, config *Config) bool {
// match: (Rsh32Ux8 <t> x (Const8 [c]))
// cond:
// result: (Rsh32Ux64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end967cea80158afaffb783f6da7aa898ca
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32Ux64)
v.AddArg(v0)
return true
}
- goto end967cea80158afaffb783f6da7aa898ca
-end967cea80158afaffb783f6da7aa898ca:
- ;
return false
}
func rewriteValuegeneric_OpRsh32x16(v *Value, config *Config) bool {
// match: (Rsh32x16 <t> x (Const16 [c]))
// cond:
// result: (Rsh32x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end6a62ebdcc98ea2e3214559214708d26a
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32x64)
v.AddArg(v0)
return true
}
- goto end6a62ebdcc98ea2e3214559214708d26a
-end6a62ebdcc98ea2e3214559214708d26a:
- ;
return false
}
func rewriteValuegeneric_OpRsh32x32(v *Value, config *Config) bool {
// match: (Rsh32x32 <t> x (Const32 [c]))
// cond:
// result: (Rsh32x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end6e3b467acdca74f58e9177fb42a1968b
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32x64)
v.AddArg(v0)
return true
}
- goto end6e3b467acdca74f58e9177fb42a1968b
-end6e3b467acdca74f58e9177fb42a1968b:
- ;
return false
}
func rewriteValuegeneric_OpRsh32x64(v *Value, config *Config) bool {
// match: (Rsh32x64 (Const32 [c]) (Const64 [d]))
// cond:
// result: (Const32 [int64(int32(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end7e4b8c499cffe1fef73a16e6be54d4d2
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end7e4b8c499cffe1fef73a16e6be54d4d2
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = int64(int32(c) >> uint64(d))
return true
}
- goto end7e4b8c499cffe1fef73a16e6be54d4d2
-end7e4b8c499cffe1fef73a16e6be54d4d2:
- ;
// match: (Rsh32x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end72da2611eaaffe407efa1cc45c23ade3
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end72da2611eaaffe407efa1cc45c23ade3
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end72da2611eaaffe407efa1cc45c23ade3
-end72da2611eaaffe407efa1cc45c23ade3:
- ;
// match: (Rsh32x64 <t> (Rsh32x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh32x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh32x64 {
- goto endadb415be78ee46a8a4135ec50df772b0
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto endadb415be78ee46a8a4135ec50df772b0
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endadb415be78ee46a8a4135ec50df772b0
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto endadb415be78ee46a8a4135ec50df772b0
+ break
}
v.reset(OpRsh32x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto endadb415be78ee46a8a4135ec50df772b0
-endadb415be78ee46a8a4135ec50df772b0:
- ;
return false
}
func rewriteValuegeneric_OpRsh32x8(v *Value, config *Config) bool {
// match: (Rsh32x8 <t> x (Const8 [c]))
// cond:
// result: (Rsh32x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end7b59b42c5c68a2d55be469a0c086dd8b
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh32x64)
v.AddArg(v0)
return true
}
- goto end7b59b42c5c68a2d55be469a0c086dd8b
-end7b59b42c5c68a2d55be469a0c086dd8b:
- ;
return false
}
func rewriteValuegeneric_OpRsh64Ux16(v *Value, config *Config) bool {
// match: (Rsh64Ux16 <t> x (Const16 [c]))
// cond:
// result: (Rsh64Ux64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end733d85a7b599bcba969ca1cb4bdb9e48
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64Ux64)
v.AddArg(v0)
return true
}
- goto end733d85a7b599bcba969ca1cb4bdb9e48
-end733d85a7b599bcba969ca1cb4bdb9e48:
- ;
return false
}
func rewriteValuegeneric_OpRsh64Ux32(v *Value, config *Config) bool {
// match: (Rsh64Ux32 <t> x (Const32 [c]))
// cond:
// result: (Rsh64Ux64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto endeac7b34169de1fb0393b833e65b9bb19
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64Ux64)
v.AddArg(v0)
return true
}
- goto endeac7b34169de1fb0393b833e65b9bb19
-endeac7b34169de1fb0393b833e65b9bb19:
- ;
return false
}
func rewriteValuegeneric_OpRsh64Ux64(v *Value, config *Config) bool {
// match: (Rsh64Ux64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [int64(uint64(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end102f4cfd7979a2aa222d52c34ac6802d
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end102f4cfd7979a2aa222d52c34ac6802d
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = int64(uint64(c) >> uint64(d))
return true
}
- goto end102f4cfd7979a2aa222d52c34ac6802d
-end102f4cfd7979a2aa222d52c34ac6802d:
- ;
// match: (Rsh64Ux64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end5ad037b910698f2847df90177c23a6ac
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end5ad037b910698f2847df90177c23a6ac
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end5ad037b910698f2847df90177c23a6ac
-end5ad037b910698f2847df90177c23a6ac:
- ;
// match: (Rsh64Ux64 _ (Const64 [c]))
// cond: uint64(c) >= 64
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto end16ea16aa61862207ea64e514369d608b
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 64) {
- goto end16ea16aa61862207ea64e514369d608b
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto end16ea16aa61862207ea64e514369d608b
-end16ea16aa61862207ea64e514369d608b:
- ;
// match: (Rsh64Ux64 <t> (Rsh64Ux64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh64Ux64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh64Ux64 {
- goto end32bfdb1b4ccc23a5cd62fc0348ebd877
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end32bfdb1b4ccc23a5cd62fc0348ebd877
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end32bfdb1b4ccc23a5cd62fc0348ebd877
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end32bfdb1b4ccc23a5cd62fc0348ebd877
+ break
}
v.reset(OpRsh64Ux64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end32bfdb1b4ccc23a5cd62fc0348ebd877
-end32bfdb1b4ccc23a5cd62fc0348ebd877:
- ;
return false
}
func rewriteValuegeneric_OpRsh64Ux8(v *Value, config *Config) bool {
// match: (Rsh64Ux8 <t> x (Const8 [c]))
// cond:
// result: (Rsh64Ux64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto ende3d8090a67a52dbcd24b52ee32c9d7f0
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64Ux64)
v.AddArg(v0)
return true
}
- goto ende3d8090a67a52dbcd24b52ee32c9d7f0
-ende3d8090a67a52dbcd24b52ee32c9d7f0:
- ;
return false
}
func rewriteValuegeneric_OpRsh64x16(v *Value, config *Config) bool {
// match: (Rsh64x16 <t> x (Const16 [c]))
// cond:
// result: (Rsh64x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto endd5151d0bfc38c55ae6ae6836014df3bc
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64x64)
v.AddArg(v0)
return true
}
- goto endd5151d0bfc38c55ae6ae6836014df3bc
-endd5151d0bfc38c55ae6ae6836014df3bc:
- ;
return false
}
func rewriteValuegeneric_OpRsh64x32(v *Value, config *Config) bool {
// match: (Rsh64x32 <t> x (Const32 [c]))
// cond:
// result: (Rsh64x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end0f2dbca5c7d6b100890c94a97bf0de7c
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64x64)
v.AddArg(v0)
return true
}
- goto end0f2dbca5c7d6b100890c94a97bf0de7c
-end0f2dbca5c7d6b100890c94a97bf0de7c:
- ;
return false
}
func rewriteValuegeneric_OpRsh64x64(v *Value, config *Config) bool {
// match: (Rsh64x64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c >> uint64(d)])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto endfa4609d6bea8a3e3d3a777b1968c97d9
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endfa4609d6bea8a3e3d3a777b1968c97d9
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = c >> uint64(d)
return true
}
- goto endfa4609d6bea8a3e3d3a777b1968c97d9
-endfa4609d6bea8a3e3d3a777b1968c97d9:
- ;
// match: (Rsh64x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto ende62e0c67d3f04eb221646371a2a91d05
+ break
}
if v.Args[1].AuxInt != 0 {
- goto ende62e0c67d3f04eb221646371a2a91d05
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto ende62e0c67d3f04eb221646371a2a91d05
-ende62e0c67d3f04eb221646371a2a91d05:
- ;
// match: (Rsh64x64 <t> (Rsh64x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh64x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh64x64 {
- goto endd3e8ea66dc3ad0bc393001d6babb7160
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto endd3e8ea66dc3ad0bc393001d6babb7160
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endd3e8ea66dc3ad0bc393001d6babb7160
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto endd3e8ea66dc3ad0bc393001d6babb7160
+ break
}
v.reset(OpRsh64x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto endd3e8ea66dc3ad0bc393001d6babb7160
-endd3e8ea66dc3ad0bc393001d6babb7160:
- ;
return false
}
func rewriteValuegeneric_OpRsh64x8(v *Value, config *Config) bool {
// match: (Rsh64x8 <t> x (Const8 [c]))
// cond:
// result: (Rsh64x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end1a9e5a89849344396210da7c7ec810be
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh64x64)
v.AddArg(v0)
return true
}
- goto end1a9e5a89849344396210da7c7ec810be
-end1a9e5a89849344396210da7c7ec810be:
- ;
return false
}
func rewriteValuegeneric_OpRsh8Ux16(v *Value, config *Config) bool {
// match: (Rsh8Ux16 <t> x (Const16 [c]))
// cond:
// result: (Rsh8Ux64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end7acc015610273092e9efcce2949ee0f9
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8Ux64)
v.AddArg(v0)
return true
}
- goto end7acc015610273092e9efcce2949ee0f9
-end7acc015610273092e9efcce2949ee0f9:
- ;
return false
}
func rewriteValuegeneric_OpRsh8Ux32(v *Value, config *Config) bool {
// match: (Rsh8Ux32 <t> x (Const32 [c]))
// cond:
// result: (Rsh8Ux64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end27e9b4472e085b653a105b1d67554ce8
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8Ux64)
v.AddArg(v0)
return true
}
- goto end27e9b4472e085b653a105b1d67554ce8
-end27e9b4472e085b653a105b1d67554ce8:
- ;
return false
}
func rewriteValuegeneric_OpRsh8Ux64(v *Value, config *Config) bool {
// match: (Rsh8Ux64 (Const8 [c]) (Const64 [d]))
// cond:
// result: (Const8 [int64(uint8(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto enddd166e450d81ba7b466d61d2fbec178c
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto enddd166e450d81ba7b466d61d2fbec178c
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = int64(uint8(c) >> uint64(d))
return true
}
- goto enddd166e450d81ba7b466d61d2fbec178c
-enddd166e450d81ba7b466d61d2fbec178c:
- ;
// match: (Rsh8Ux64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end570cb1d9db3c7bebd85e485eeb2c0969
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end570cb1d9db3c7bebd85e485eeb2c0969
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end570cb1d9db3c7bebd85e485eeb2c0969
-end570cb1d9db3c7bebd85e485eeb2c0969:
- ;
// match: (Rsh8Ux64 _ (Const64 [c]))
// cond: uint64(c) >= 8
// result: (Const64 [0])
- {
+ for {
if v.Args[1].Op != OpConst64 {
- goto endb63e1a7d1d91716ca0d9d74215361323
+ break
}
c := v.Args[1].AuxInt
if !(uint64(c) >= 8) {
- goto endb63e1a7d1d91716ca0d9d74215361323
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto endb63e1a7d1d91716ca0d9d74215361323
-endb63e1a7d1d91716ca0d9d74215361323:
- ;
// match: (Rsh8Ux64 <t> (Rsh8Ux64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh8Ux64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh8Ux64 {
- goto endee8824b7071ed1a6dba4fcbaab98229e
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto endee8824b7071ed1a6dba4fcbaab98229e
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto endee8824b7071ed1a6dba4fcbaab98229e
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto endee8824b7071ed1a6dba4fcbaab98229e
+ break
}
v.reset(OpRsh8Ux64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto endee8824b7071ed1a6dba4fcbaab98229e
-endee8824b7071ed1a6dba4fcbaab98229e:
- ;
return false
}
func rewriteValuegeneric_OpRsh8Ux8(v *Value, config *Config) bool {
// match: (Rsh8Ux8 <t> x (Const8 [c]))
// cond:
// result: (Rsh8Ux64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto ended7e4f4d9ab89dc26e6649d466577930
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8Ux64)
v.AddArg(v0)
return true
}
- goto ended7e4f4d9ab89dc26e6649d466577930
-ended7e4f4d9ab89dc26e6649d466577930:
- ;
return false
}
func rewriteValuegeneric_OpRsh8x16(v *Value, config *Config) bool {
// match: (Rsh8x16 <t> x (Const16 [c]))
// cond:
// result: (Rsh8x64 x (Const64 <t> [int64(uint16(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end136bef6f60180bc8b4befbfc370af7ef
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8x64)
v.AddArg(v0)
return true
}
- goto end136bef6f60180bc8b4befbfc370af7ef
-end136bef6f60180bc8b4befbfc370af7ef:
- ;
return false
}
func rewriteValuegeneric_OpRsh8x32(v *Value, config *Config) bool {
// match: (Rsh8x32 <t> x (Const32 [c]))
// cond:
// result: (Rsh8x64 x (Const64 <t> [int64(uint32(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end2ef95c222a7c552fa9cc86e36196644e
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8x64)
v.AddArg(v0)
return true
}
- goto end2ef95c222a7c552fa9cc86e36196644e
-end2ef95c222a7c552fa9cc86e36196644e:
- ;
return false
}
func rewriteValuegeneric_OpRsh8x64(v *Value, config *Config) bool {
// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
// cond:
// result: (Const8 [int64(int8(c) >> uint64(d))])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto end3b90206d75365466dfd1368e5b69db35
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end3b90206d75365466dfd1368e5b69db35
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = int64(int8(c) >> uint64(d))
return true
}
- goto end3b90206d75365466dfd1368e5b69db35
-end3b90206d75365466dfd1368e5b69db35:
- ;
// match: (Rsh8x64 x (Const64 [0]))
// cond:
// result: x
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto end1e664cc720a11d1c769de8081cfa1de4
+ break
}
if v.Args[1].AuxInt != 0 {
- goto end1e664cc720a11d1c769de8081cfa1de4
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end1e664cc720a11d1c769de8081cfa1de4
-end1e664cc720a11d1c769de8081cfa1de4:
- ;
// match: (Rsh8x64 <t> (Rsh8x64 x (Const64 [c])) (Const64 [d]))
// cond: !uaddOvf(c,d)
// result: (Rsh8x64 x (Const64 <t> [c+d]))
- {
+ for {
t := v.Type
if v.Args[0].Op != OpRsh8x64 {
- goto end6408685a7276af7e76ec086f359c942c
+ break
}
x := v.Args[0].Args[0]
if v.Args[0].Args[1].Op != OpConst64 {
- goto end6408685a7276af7e76ec086f359c942c
+ break
}
c := v.Args[0].Args[1].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end6408685a7276af7e76ec086f359c942c
+ break
}
d := v.Args[1].AuxInt
if !(!uaddOvf(c, d)) {
- goto end6408685a7276af7e76ec086f359c942c
+ break
}
v.reset(OpRsh8x64)
v.AddArg(x)
v.AddArg(v0)
return true
}
- goto end6408685a7276af7e76ec086f359c942c
-end6408685a7276af7e76ec086f359c942c:
- ;
return false
}
func rewriteValuegeneric_OpRsh8x8(v *Value, config *Config) bool {
// match: (Rsh8x8 <t> x (Const8 [c]))
// cond:
// result: (Rsh8x64 x (Const64 <t> [int64(uint8(c))]))
- {
+ for {
t := v.Type
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto endae44f60f364cddd8903763dd921a007e
+ break
}
c := v.Args[1].AuxInt
v.reset(OpRsh8x64)
v.AddArg(v0)
return true
}
- goto endae44f60f364cddd8903763dd921a007e
-endae44f60f364cddd8903763dd921a007e:
- ;
return false
}
func rewriteValuegeneric_OpSliceCap(v *Value, config *Config) bool {
// match: (SliceCap (SliceMake _ _ cap))
// cond:
// result: cap
- {
+ for {
if v.Args[0].Op != OpSliceMake {
- goto end1bd11616743632b33b410964667fb3c6
+ break
}
cap := v.Args[0].Args[2]
v.reset(OpCopy)
v.AddArg(cap)
return true
}
- goto end1bd11616743632b33b410964667fb3c6
-end1bd11616743632b33b410964667fb3c6:
- ;
return false
}
func rewriteValuegeneric_OpSliceLen(v *Value, config *Config) bool {
// match: (SliceLen (SliceMake _ len _))
// cond:
// result: len
- {
+ for {
if v.Args[0].Op != OpSliceMake {
- goto endebb2090199d13e4c2ae52fb3e778f7fd
+ break
}
len := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(len)
return true
}
- goto endebb2090199d13e4c2ae52fb3e778f7fd
-endebb2090199d13e4c2ae52fb3e778f7fd:
- ;
return false
}
func rewriteValuegeneric_OpSlicePtr(v *Value, config *Config) bool {
// match: (SlicePtr (SliceMake ptr _ _ ))
// cond:
// result: ptr
- {
+ for {
if v.Args[0].Op != OpSliceMake {
- goto end526acc0a705137a5d25577499206720b
+ break
}
ptr := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(ptr)
return true
}
- goto end526acc0a705137a5d25577499206720b
-end526acc0a705137a5d25577499206720b:
- ;
return false
}
func rewriteValuegeneric_OpStore(v *Value, config *Config) bool {
// match: (Store _ (StructMake0) mem)
// cond:
// result: mem
- {
+ for {
if v.Args[1].Op != OpStructMake0 {
- goto endd4f364b0adfc229d8c200af183d4c808
+ break
}
mem := v.Args[2]
v.reset(OpCopy)
v.AddArg(mem)
return true
}
- goto endd4f364b0adfc229d8c200af183d4c808
-endd4f364b0adfc229d8c200af183d4c808:
- ;
// match: (Store dst (StructMake1 <t> f0) mem)
// cond:
// result: (Store [t.FieldType(0).Size()] dst f0 mem)
- {
+ for {
dst := v.Args[0]
if v.Args[1].Op != OpStructMake1 {
- goto end2cff6d06f4440132f48ca374b6b1e9d8
+ break
}
t := v.Args[1].Type
f0 := v.Args[1].Args[0]
v.AddArg(mem)
return true
}
- goto end2cff6d06f4440132f48ca374b6b1e9d8
-end2cff6d06f4440132f48ca374b6b1e9d8:
- ;
// match: (Store dst (StructMake2 <t> f0 f1) mem)
// cond:
// result: (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))
- {
+ for {
dst := v.Args[0]
if v.Args[1].Op != OpStructMake2 {
- goto end4e8ede6cc575a287795971da6b637973
+ break
}
t := v.Args[1].Type
f0 := v.Args[1].Args[0]
v.AddArg(v1)
return true
}
- goto end4e8ede6cc575a287795971da6b637973
-end4e8ede6cc575a287795971da6b637973:
- ;
// match: (Store dst (StructMake3 <t> f0 f1 f2) mem)
// cond:
// result: (Store [t.FieldType(2).Size()] (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem)))
- {
+ for {
dst := v.Args[0]
if v.Args[1].Op != OpStructMake3 {
- goto end6ad675267724a87c8f852dd1e185e911
+ break
}
t := v.Args[1].Type
f0 := v.Args[1].Args[0]
v.AddArg(v1)
return true
}
- goto end6ad675267724a87c8f852dd1e185e911
-end6ad675267724a87c8f852dd1e185e911:
- ;
// match: (Store dst (StructMake4 <t> f0 f1 f2 f3) mem)
// cond:
// result: (Store [t.FieldType(3).Size()] (OffPtr <t.FieldType(3).PtrTo()> [t.FieldOff(3)] dst) f3 (Store [t.FieldType(2).Size()] (OffPtr <t.FieldType(2).PtrTo()> [t.FieldOff(2)] dst) f2 (Store [t.FieldType(1).Size()] (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store [t.FieldType(0).Size()] dst f0 mem))))
- {
+ for {
dst := v.Args[0]
if v.Args[1].Op != OpStructMake4 {
- goto end7ea91abd44794f7653374502a5a405ea
+ break
}
t := v.Args[1].Type
f0 := v.Args[1].Args[0]
v.AddArg(v1)
return true
}
- goto end7ea91abd44794f7653374502a5a405ea
-end7ea91abd44794f7653374502a5a405ea:
- ;
// match: (Store [8] dst (ComplexMake real imag) mem)
// cond:
// result: (Store [4] (OffPtr <config.fe.TypeFloat32().PtrTo()> [4] dst) imag (Store [4] dst real mem))
- {
+ for {
if v.AuxInt != 8 {
- goto endced898cb0a165662afe48ea44ad3318a
+ break
}
dst := v.Args[0]
if v.Args[1].Op != OpComplexMake {
- goto endced898cb0a165662afe48ea44ad3318a
+ break
}
real := v.Args[1].Args[0]
imag := v.Args[1].Args[1]
v.AddArg(v1)
return true
}
- goto endced898cb0a165662afe48ea44ad3318a
-endced898cb0a165662afe48ea44ad3318a:
- ;
// match: (Store [16] dst (ComplexMake real imag) mem)
// cond:
// result: (Store [8] (OffPtr <config.fe.TypeFloat64().PtrTo()> [8] dst) imag (Store [8] dst real mem))
- {
+ for {
if v.AuxInt != 16 {
- goto end3851a482d7bd37a93c4d81581e85b3ab
+ break
}
dst := v.Args[0]
if v.Args[1].Op != OpComplexMake {
- goto end3851a482d7bd37a93c4d81581e85b3ab
+ break
}
real := v.Args[1].Args[0]
imag := v.Args[1].Args[1]
v.AddArg(v1)
return true
}
- goto end3851a482d7bd37a93c4d81581e85b3ab
-end3851a482d7bd37a93c4d81581e85b3ab:
- ;
// match: (Store [2*config.PtrSize] dst (StringMake ptr len) mem)
// cond:
// result: (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem))
- {
+ for {
if v.AuxInt != 2*config.PtrSize {
- goto endd3a6ecebdad5899570a79fe5c62f34f1
+ break
}
dst := v.Args[0]
if v.Args[1].Op != OpStringMake {
- goto endd3a6ecebdad5899570a79fe5c62f34f1
+ break
}
ptr := v.Args[1].Args[0]
len := v.Args[1].Args[1]
v.AddArg(v1)
return true
}
- goto endd3a6ecebdad5899570a79fe5c62f34f1
-endd3a6ecebdad5899570a79fe5c62f34f1:
- ;
// match: (Store [3*config.PtrSize] dst (SliceMake ptr len cap) mem)
// cond:
// result: (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [2*config.PtrSize] dst) cap (Store [config.PtrSize] (OffPtr <config.fe.TypeInt().PtrTo()> [config.PtrSize] dst) len (Store [config.PtrSize] dst ptr mem)))
- {
+ for {
if v.AuxInt != 3*config.PtrSize {
- goto endd5cc8c3dad7d24c845b0b88fc51487ae
+ break
}
dst := v.Args[0]
if v.Args[1].Op != OpSliceMake {
- goto endd5cc8c3dad7d24c845b0b88fc51487ae
+ break
}
ptr := v.Args[1].Args[0]
len := v.Args[1].Args[1]
v.AddArg(v1)
return true
}
- goto endd5cc8c3dad7d24c845b0b88fc51487ae
-endd5cc8c3dad7d24c845b0b88fc51487ae:
- ;
// match: (Store [2*config.PtrSize] dst (IMake itab data) mem)
// cond:
// result: (Store [config.PtrSize] (OffPtr <config.fe.TypeBytePtr().PtrTo()> [config.PtrSize] dst) data (Store [config.PtrSize] dst itab mem))
- {
+ for {
if v.AuxInt != 2*config.PtrSize {
- goto endaa801a871178ae3256b3f6f5d9f13514
+ break
}
dst := v.Args[0]
if v.Args[1].Op != OpIMake {
- goto endaa801a871178ae3256b3f6f5d9f13514
+ break
}
itab := v.Args[1].Args[0]
data := v.Args[1].Args[1]
v.AddArg(v1)
return true
}
- goto endaa801a871178ae3256b3f6f5d9f13514
-endaa801a871178ae3256b3f6f5d9f13514:
- ;
// match: (Store [size] dst (Load <t> src mem) mem)
// cond: !config.fe.CanSSA(t)
// result: (Move [size] dst src mem)
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
if v.Args[1].Op != OpLoad {
- goto end45295326269ba18413dceb7b608a0b9d
+ break
}
t := v.Args[1].Type
src := v.Args[1].Args[0]
mem := v.Args[1].Args[1]
if v.Args[2] != mem {
- goto end45295326269ba18413dceb7b608a0b9d
+ break
}
if !(!config.fe.CanSSA(t)) {
- goto end45295326269ba18413dceb7b608a0b9d
+ break
}
v.reset(OpMove)
v.AuxInt = size
v.AddArg(mem)
return true
}
- goto end45295326269ba18413dceb7b608a0b9d
-end45295326269ba18413dceb7b608a0b9d:
- ;
// match: (Store [size] dst (Load <t> src mem) (VarDef {x} mem))
// cond: !config.fe.CanSSA(t)
// result: (Move [size] dst src (VarDef {x} mem))
- {
+ for {
size := v.AuxInt
dst := v.Args[0]
if v.Args[1].Op != OpLoad {
- goto end7f3cc0baffb82ba3ee879599b189a512
+ break
}
t := v.Args[1].Type
src := v.Args[1].Args[0]
mem := v.Args[1].Args[1]
if v.Args[2].Op != OpVarDef {
- goto end7f3cc0baffb82ba3ee879599b189a512
+ break
}
x := v.Args[2].Aux
if v.Args[2].Args[0] != mem {
- goto end7f3cc0baffb82ba3ee879599b189a512
+ break
}
if !(!config.fe.CanSSA(t)) {
- goto end7f3cc0baffb82ba3ee879599b189a512
+ break
}
v.reset(OpMove)
v.AuxInt = size
v.AddArg(v0)
return true
}
- goto end7f3cc0baffb82ba3ee879599b189a512
-end7f3cc0baffb82ba3ee879599b189a512:
- ;
return false
}
func rewriteValuegeneric_OpStringLen(v *Value, config *Config) bool {
// match: (StringLen (StringMake _ len))
// cond:
// result: len
- {
+ for {
if v.Args[0].Op != OpStringMake {
- goto end0d922460b7e5ca88324034f4bd6c027c
+ break
}
len := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(len)
return true
}
- goto end0d922460b7e5ca88324034f4bd6c027c
-end0d922460b7e5ca88324034f4bd6c027c:
- ;
return false
}
func rewriteValuegeneric_OpStringPtr(v *Value, config *Config) bool {
// match: (StringPtr (StringMake ptr _))
// cond:
// result: ptr
- {
+ for {
if v.Args[0].Op != OpStringMake {
- goto end061edc5d85c73ad909089af2556d9380
+ break
}
ptr := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(ptr)
return true
}
- goto end061edc5d85c73ad909089af2556d9380
-end061edc5d85c73ad909089af2556d9380:
- ;
return false
}
func rewriteValuegeneric_OpStructSelect(v *Value, config *Config) bool {
// match: (StructSelect (StructMake1 x))
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpStructMake1 {
- goto end17af582e7eba5216b4a51fe6c9206d3c
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end17af582e7eba5216b4a51fe6c9206d3c
-end17af582e7eba5216b4a51fe6c9206d3c:
- ;
// match: (StructSelect [0] (StructMake2 x _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto end355cfff99c8e9af975c3ae450d49b7f9
+ break
}
if v.Args[0].Op != OpStructMake2 {
- goto end355cfff99c8e9af975c3ae450d49b7f9
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end355cfff99c8e9af975c3ae450d49b7f9
-end355cfff99c8e9af975c3ae450d49b7f9:
- ;
// match: (StructSelect [1] (StructMake2 _ x))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 1 {
- goto end69baa65e494ef9ae154e0943b53734f9
+ break
}
if v.Args[0].Op != OpStructMake2 {
- goto end69baa65e494ef9ae154e0943b53734f9
+ break
}
x := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end69baa65e494ef9ae154e0943b53734f9
-end69baa65e494ef9ae154e0943b53734f9:
- ;
// match: (StructSelect [0] (StructMake3 x _ _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto endb0d98e2c46bb51c9abd4c3543392e0ec
+ break
}
if v.Args[0].Op != OpStructMake3 {
- goto endb0d98e2c46bb51c9abd4c3543392e0ec
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto endb0d98e2c46bb51c9abd4c3543392e0ec
-endb0d98e2c46bb51c9abd4c3543392e0ec:
- ;
// match: (StructSelect [1] (StructMake3 _ x _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 1 {
- goto end2e40457286d26c2f14ad4fd127946773
+ break
}
if v.Args[0].Op != OpStructMake3 {
- goto end2e40457286d26c2f14ad4fd127946773
+ break
}
x := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end2e40457286d26c2f14ad4fd127946773
-end2e40457286d26c2f14ad4fd127946773:
- ;
// match: (StructSelect [2] (StructMake3 _ _ x))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 2 {
- goto end3e3b96ad431206175d002ece87aa1409
+ break
}
if v.Args[0].Op != OpStructMake3 {
- goto end3e3b96ad431206175d002ece87aa1409
+ break
}
x := v.Args[0].Args[2]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end3e3b96ad431206175d002ece87aa1409
-end3e3b96ad431206175d002ece87aa1409:
- ;
// match: (StructSelect [0] (StructMake4 x _ _ _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 0 {
- goto end09f8a1ffa3d8c3124bc6d4083b941108
+ break
}
if v.Args[0].Op != OpStructMake4 {
- goto end09f8a1ffa3d8c3124bc6d4083b941108
+ break
}
x := v.Args[0].Args[0]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end09f8a1ffa3d8c3124bc6d4083b941108
-end09f8a1ffa3d8c3124bc6d4083b941108:
- ;
// match: (StructSelect [1] (StructMake4 _ x _ _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 1 {
- goto endd3ef25e605a927e9251be6d9221f4acf
+ break
}
if v.Args[0].Op != OpStructMake4 {
- goto endd3ef25e605a927e9251be6d9221f4acf
+ break
}
x := v.Args[0].Args[1]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto endd3ef25e605a927e9251be6d9221f4acf
-endd3ef25e605a927e9251be6d9221f4acf:
- ;
// match: (StructSelect [2] (StructMake4 _ _ x _))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 2 {
- goto end0438e22cc8f41123fa42009a81ee723a
+ break
}
if v.Args[0].Op != OpStructMake4 {
- goto end0438e22cc8f41123fa42009a81ee723a
+ break
}
x := v.Args[0].Args[2]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end0438e22cc8f41123fa42009a81ee723a
-end0438e22cc8f41123fa42009a81ee723a:
- ;
// match: (StructSelect [3] (StructMake4 _ _ _ x))
// cond:
// result: x
- {
+ for {
if v.AuxInt != 3 {
- goto end56a7c7781fee35eeff0a3652dc206012
+ break
}
if v.Args[0].Op != OpStructMake4 {
- goto end56a7c7781fee35eeff0a3652dc206012
+ break
}
x := v.Args[0].Args[3]
v.reset(OpCopy)
v.AddArg(x)
return true
}
- goto end56a7c7781fee35eeff0a3652dc206012
-end56a7c7781fee35eeff0a3652dc206012:
- ;
// match: (StructSelect [i] (Load <t> ptr mem))
// cond: !config.fe.CanSSA(t)
// result: @v.Args[0].Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(i)] ptr) mem)
- {
+ for {
i := v.AuxInt
if v.Args[0].Op != OpLoad {
- goto end2afd47b4fcaaab7a73325bd8a75e3e8e
+ break
}
t := v.Args[0].Type
ptr := v.Args[0].Args[0]
mem := v.Args[0].Args[1]
if !(!config.fe.CanSSA(t)) {
- goto end2afd47b4fcaaab7a73325bd8a75e3e8e
+ break
}
v0 := v.Args[0].Block.NewValue0(v.Line, OpLoad, v.Type)
v.reset(OpCopy)
v0.AddArg(mem)
return true
}
- goto end2afd47b4fcaaab7a73325bd8a75e3e8e
-end2afd47b4fcaaab7a73325bd8a75e3e8e:
- ;
return false
}
func rewriteValuegeneric_OpSub16(v *Value, config *Config) bool {
// match: (Sub16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [c-d])
- {
+ for {
if v.Args[0].Op != OpConst16 {
- goto end5c6fab95c9dbeff5973119096bfd4e78
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst16 {
- goto end5c6fab95c9dbeff5973119096bfd4e78
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst16)
v.AuxInt = c - d
return true
}
- goto end5c6fab95c9dbeff5973119096bfd4e78
-end5c6fab95c9dbeff5973119096bfd4e78:
- ;
// match: (Sub16 x (Const16 <t> [c]))
// cond: x.Op != OpConst16
// result: (Add16 (Const16 <t> [-c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst16 {
- goto end493545258a8e7e79d005b34c712ddd0c
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst16) {
- goto end493545258a8e7e79d005b34c712ddd0c
+ break
}
v.reset(OpAdd16)
v0 := b.NewValue0(v.Line, OpConst16, t)
v.AddArg(x)
return true
}
- goto end493545258a8e7e79d005b34c712ddd0c
-end493545258a8e7e79d005b34c712ddd0c:
- ;
// match: (Sub16 x x)
// cond:
// result: (Const16 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end83da541391be564f2a08464e674a49e7
+ break
}
v.reset(OpConst16)
v.AuxInt = 0
return true
}
- goto end83da541391be564f2a08464e674a49e7
-end83da541391be564f2a08464e674a49e7:
- ;
// match: (Sub16 (Add16 x y) x)
// cond:
// result: y
- {
+ for {
if v.Args[0].Op != OpAdd16 {
- goto end0dd8f250c457b9c005ecbed59fc2e758
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != x {
- goto end0dd8f250c457b9c005ecbed59fc2e758
+ break
}
v.reset(OpCopy)
v.Type = y.Type
v.AddArg(y)
return true
}
- goto end0dd8f250c457b9c005ecbed59fc2e758
-end0dd8f250c457b9c005ecbed59fc2e758:
- ;
// match: (Sub16 (Add16 x y) y)
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpAdd16 {
- goto end01c8db2e0bce69e048cf79f3bdc82b9b
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != y {
- goto end01c8db2e0bce69e048cf79f3bdc82b9b
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end01c8db2e0bce69e048cf79f3bdc82b9b
-end01c8db2e0bce69e048cf79f3bdc82b9b:
- ;
return false
}
func rewriteValuegeneric_OpSub32(v *Value, config *Config) bool {
// match: (Sub32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [c-d])
- {
+ for {
if v.Args[0].Op != OpConst32 {
- goto end7623799db780e1bcc42c6ea0df9c49d3
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst32 {
- goto end7623799db780e1bcc42c6ea0df9c49d3
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst32)
v.AuxInt = c - d
return true
}
- goto end7623799db780e1bcc42c6ea0df9c49d3
-end7623799db780e1bcc42c6ea0df9c49d3:
- ;
// match: (Sub32 x (Const32 <t> [c]))
// cond: x.Op != OpConst32
// result: (Add32 (Const32 <t> [-c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst32 {
- goto end391e2f2ba8c7502b62c0153ec69c4fbd
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst32) {
- goto end391e2f2ba8c7502b62c0153ec69c4fbd
+ break
}
v.reset(OpAdd32)
v0 := b.NewValue0(v.Line, OpConst32, t)
v.AddArg(x)
return true
}
- goto end391e2f2ba8c7502b62c0153ec69c4fbd
-end391e2f2ba8c7502b62c0153ec69c4fbd:
- ;
// match: (Sub32 x x)
// cond:
// result: (Const32 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto enda747581e798f199e07f4ad69747cd069
+ break
}
v.reset(OpConst32)
v.AuxInt = 0
return true
}
- goto enda747581e798f199e07f4ad69747cd069
-enda747581e798f199e07f4ad69747cd069:
- ;
// match: (Sub32 (Add32 x y) x)
// cond:
// result: y
- {
+ for {
if v.Args[0].Op != OpAdd32 {
- goto end70c1e60e58a6c106d060f10cd3f179ea
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != x {
- goto end70c1e60e58a6c106d060f10cd3f179ea
+ break
}
v.reset(OpCopy)
v.Type = y.Type
v.AddArg(y)
return true
}
- goto end70c1e60e58a6c106d060f10cd3f179ea
-end70c1e60e58a6c106d060f10cd3f179ea:
- ;
// match: (Sub32 (Add32 x y) y)
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpAdd32 {
- goto end20e42db178ec4f423cc56a991863a4a2
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != y {
- goto end20e42db178ec4f423cc56a991863a4a2
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end20e42db178ec4f423cc56a991863a4a2
-end20e42db178ec4f423cc56a991863a4a2:
- ;
return false
}
func rewriteValuegeneric_OpSub64(v *Value, config *Config) bool {
// match: (Sub64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c-d])
- {
+ for {
if v.Args[0].Op != OpConst64 {
- goto end5a84a285ff0ff48b8ad3c64b15e3459f
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst64 {
- goto end5a84a285ff0ff48b8ad3c64b15e3459f
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst64)
v.AuxInt = c - d
return true
}
- goto end5a84a285ff0ff48b8ad3c64b15e3459f
-end5a84a285ff0ff48b8ad3c64b15e3459f:
- ;
// match: (Sub64 x (Const64 <t> [c]))
// cond: x.Op != OpConst64
// result: (Add64 (Const64 <t> [-c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst64 {
- goto enda80d30f6794bcf02cd4442b238f68333
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst64) {
- goto enda80d30f6794bcf02cd4442b238f68333
+ break
}
v.reset(OpAdd64)
v0 := b.NewValue0(v.Line, OpConst64, t)
v.AddArg(x)
return true
}
- goto enda80d30f6794bcf02cd4442b238f68333
-enda80d30f6794bcf02cd4442b238f68333:
- ;
// match: (Sub64 x x)
// cond:
// result: (Const64 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end0387dc2b7bbe57d4aa54eab5d959da4b
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto end0387dc2b7bbe57d4aa54eab5d959da4b
-end0387dc2b7bbe57d4aa54eab5d959da4b:
- ;
// match: (Sub64 (Add64 x y) x)
// cond:
// result: y
- {
+ for {
if v.Args[0].Op != OpAdd64 {
- goto end7d177451cf8959cb781f52d5ded46fff
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != x {
- goto end7d177451cf8959cb781f52d5ded46fff
+ break
}
v.reset(OpCopy)
v.Type = y.Type
v.AddArg(y)
return true
}
- goto end7d177451cf8959cb781f52d5ded46fff
-end7d177451cf8959cb781f52d5ded46fff:
- ;
// match: (Sub64 (Add64 x y) y)
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpAdd64 {
- goto end6ea8172b21100cfe3dc86b7a850fbe97
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != y {
- goto end6ea8172b21100cfe3dc86b7a850fbe97
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto end6ea8172b21100cfe3dc86b7a850fbe97
-end6ea8172b21100cfe3dc86b7a850fbe97:
- ;
return false
}
func rewriteValuegeneric_OpSub8(v *Value, config *Config) bool {
// match: (Sub8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [c-d])
- {
+ for {
if v.Args[0].Op != OpConst8 {
- goto endc00ea11c7535529e211710574f5cff24
+ break
}
c := v.Args[0].AuxInt
if v.Args[1].Op != OpConst8 {
- goto endc00ea11c7535529e211710574f5cff24
+ break
}
d := v.Args[1].AuxInt
v.reset(OpConst8)
v.AuxInt = c - d
return true
}
- goto endc00ea11c7535529e211710574f5cff24
-endc00ea11c7535529e211710574f5cff24:
- ;
// match: (Sub8 x (Const8 <t> [c]))
// cond: x.Op != OpConst8
// result: (Add8 (Const8 <t> [-c]) x)
- {
+ for {
x := v.Args[0]
if v.Args[1].Op != OpConst8 {
- goto end0bfab5b6f1037e55dc049b79e2636678
+ break
}
t := v.Args[1].Type
c := v.Args[1].AuxInt
if !(x.Op != OpConst8) {
- goto end0bfab5b6f1037e55dc049b79e2636678
+ break
}
v.reset(OpAdd8)
v0 := b.NewValue0(v.Line, OpConst8, t)
v.AddArg(x)
return true
}
- goto end0bfab5b6f1037e55dc049b79e2636678
-end0bfab5b6f1037e55dc049b79e2636678:
- ;
// match: (Sub8 x x)
// cond:
// result: (Const8 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end4e2ee15ef17611919a1a6b5f80bbfe18
+ break
}
v.reset(OpConst8)
v.AuxInt = 0
return true
}
- goto end4e2ee15ef17611919a1a6b5f80bbfe18
-end4e2ee15ef17611919a1a6b5f80bbfe18:
- ;
// match: (Sub8 (Add8 x y) x)
// cond:
// result: y
- {
+ for {
if v.Args[0].Op != OpAdd8 {
- goto endd79d561e14dc3d11da4c3bb20270b541
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != x {
- goto endd79d561e14dc3d11da4c3bb20270b541
+ break
}
v.reset(OpCopy)
v.Type = y.Type
v.AddArg(y)
return true
}
- goto endd79d561e14dc3d11da4c3bb20270b541
-endd79d561e14dc3d11da4c3bb20270b541:
- ;
// match: (Sub8 (Add8 x y) y)
// cond:
// result: x
- {
+ for {
if v.Args[0].Op != OpAdd8 {
- goto endcb7111b11d6d068c97026a97ecff8248
+ break
}
x := v.Args[0].Args[0]
y := v.Args[0].Args[1]
if v.Args[1] != y {
- goto endcb7111b11d6d068c97026a97ecff8248
+ break
}
v.reset(OpCopy)
v.Type = x.Type
v.AddArg(x)
return true
}
- goto endcb7111b11d6d068c97026a97ecff8248
-endcb7111b11d6d068c97026a97ecff8248:
- ;
return false
}
func rewriteValuegeneric_OpXor16(v *Value, config *Config) bool {
// match: (Xor16 x x)
// cond:
// result: (Const16 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end5733ceb1903b8140248d8e2cac02fefe
+ break
}
v.reset(OpConst16)
v.AuxInt = 0
return true
}
- goto end5733ceb1903b8140248d8e2cac02fefe
-end5733ceb1903b8140248d8e2cac02fefe:
- ;
return false
}
func rewriteValuegeneric_OpXor32(v *Value, config *Config) bool {
// match: (Xor32 x x)
// cond:
// result: (Const32 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end268ca02df6515d648e0bfb4e90981d25
+ break
}
v.reset(OpConst32)
v.AuxInt = 0
return true
}
- goto end268ca02df6515d648e0bfb4e90981d25
-end268ca02df6515d648e0bfb4e90981d25:
- ;
return false
}
func rewriteValuegeneric_OpXor64(v *Value, config *Config) bool {
// match: (Xor64 x x)
// cond:
// result: (Const64 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto endaf44e7f9fc58af30df69070953fb45ce
+ break
}
v.reset(OpConst64)
v.AuxInt = 0
return true
}
- goto endaf44e7f9fc58af30df69070953fb45ce
-endaf44e7f9fc58af30df69070953fb45ce:
- ;
return false
}
func rewriteValuegeneric_OpXor8(v *Value, config *Config) bool {
// match: (Xor8 x x)
// cond:
// result: (Const8 [0])
- {
+ for {
x := v.Args[0]
if v.Args[1] != x {
- goto end949b3a60b7d181688e6f79f93c782fc8
+ break
}
v.reset(OpConst8)
v.AuxInt = 0
return true
}
- goto end949b3a60b7d181688e6f79f93c782fc8
-end949b3a60b7d181688e6f79f93c782fc8:
- ;
return false
}
func rewriteBlockgeneric(b *Block) bool {
// match: (Check (NilCheck (GetG _) _) next)
// cond:
// result: (Plain nil next)
- {
+ for {
v := b.Control
if v.Op != OpNilCheck {
- goto end6e20d932d6961903b0dcf16eac513826
+ break
}
if v.Args[0].Op != OpGetG {
- goto end6e20d932d6961903b0dcf16eac513826
+ break
}
next := b.Succs[0]
b.Kind = BlockPlain
b.Likely = BranchUnknown
return true
}
- goto end6e20d932d6961903b0dcf16eac513826
- end6e20d932d6961903b0dcf16eac513826:
- ;
case BlockIf:
// match: (If (Not cond) yes no)
// cond:
// result: (If cond no yes)
- {
+ for {
v := b.Control
if v.Op != OpNot {
- goto endebe19c1c3c3bec068cdb2dd29ef57f96
+ break
}
cond := v.Args[0]
yes := b.Succs[0]
b.Likely *= -1
return true
}
- goto endebe19c1c3c3bec068cdb2dd29ef57f96
- endebe19c1c3c3bec068cdb2dd29ef57f96:
- ;
// match: (If (ConstBool [c]) yes no)
// cond: c == 1
// result: (First nil yes no)
- {
+ for {
v := b.Control
if v.Op != OpConstBool {
- goto endc58ecbb85af78c0d58bb232ca86b67a4
+ break
}
c := v.AuxInt
yes := b.Succs[0]
no := b.Succs[1]
if !(c == 1) {
- goto endc58ecbb85af78c0d58bb232ca86b67a4
+ break
}
b.Kind = BlockFirst
b.Control = nil
b.Succs[1] = no
return true
}
- goto endc58ecbb85af78c0d58bb232ca86b67a4
- endc58ecbb85af78c0d58bb232ca86b67a4:
- ;
// match: (If (ConstBool [c]) yes no)
// cond: c == 0
// result: (First nil no yes)
- {
+ for {
v := b.Control
if v.Op != OpConstBool {
- goto end4c3e297e275dd7e2e67f8ccd348c4bb5
+ break
}
c := v.AuxInt
yes := b.Succs[0]
no := b.Succs[1]
if !(c == 0) {
- goto end4c3e297e275dd7e2e67f8ccd348c4bb5
+ break
}
b.Kind = BlockFirst
b.Control = nil
b.Likely *= -1
return true
}
- goto end4c3e297e275dd7e2e67f8ccd348c4bb5
- end4c3e297e275dd7e2e67f8ccd348c4bb5:
}
return false
}