Skip to content

G
go
Commit fc7b83d1 authored by Josh Bleecher Snyder's avatar Josh Bleecher Snyder
Browse files
Options

cmd/compile: break up large value rewrite functions 

This makes the cmd/compile/internal/ssa package
compile much faster, and has no impact
on the speed of the compiler.

The chunk size was selected empirically,
in that at chunk size 10, the object
file was smaller than at chunk size 5 or 20.

name  old time/op       new time/op       delta
SSA         7.33s ± 5%        5.64s ± 1%  -23.10%  (p=0.000 n=10+10)

name  old user-time/op  new user-time/op  delta
SSA         9.70s ± 1%        8.04s ± 2%  -17.17%  (p=0.000 n=9+10)

name  old obj-bytes     new obj-bytes     delta
SSA         9.82M ± 0%        8.28M ± 0%  -15.67%  (p=0.000 n=10+10)

Change-Id: Iab472905da3f0e82f3db2c93d06e2759abc9dd44
Reviewed-on: https://go-review.googlesource.com/41296Reviewed-by: default avatarKeith Randall <khr@golang.org>
parent eaa198f3
Show whitespace changes
Inline Side-by-side
Showing with 6686 additions and 5831 deletions
src/cmd/compile/internal/ssa/gen/rulegen.go
View file @ fc7b83d1
......@@ -162,12 +162,20 @@ func genRules(arch arch) {
fmt.Fprintln(w, "var _ = objabi.GOROOT // in case not otherwise used")
fmt.Fprintln(w)
const chunkSize = 10
// Main rewrite routine is a switch on v.Op.
fmt.Fprintf(w, "func rewriteValue%s(v *Value) bool {\n", arch.name)
fmt.Fprintf(w, "switch v.Op {\n")
for _, op := range ops {
fmt.Fprintf(w, "case %s:\n", op)
fmt.Fprintf(w, "return rewriteValue%s_%s(v)\n", arch.name, op)
fmt.Fprint(w, "return ")
for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
if chunk > 0 {
fmt.Fprint(w, " || ")
}
fmt.Fprintf(w, "rewriteValue%s_%s_%d(v)", arch.name, op, chunk)
}
fmt.Fprintln(w)
}
fmt.Fprintf(w, "}\n")
fmt.Fprintf(w, "return false\n")
......@@ -176,9 +184,14 @@ func genRules(arch arch) {
// Generate a routine per op. Note that we don't make one giant routine
// because it is too big for some compilers.
for _, op := range ops {
for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
buf := new(bytes.Buffer)
var canFail bool
for i, rule := range oprules[op] {
endchunk := chunk + chunkSize
if endchunk > len(oprules[op]) {
endchunk = len(oprules[op])
}
for i, rule := range oprules[op][chunk:endchunk] {
match, cond, result := rule.parse()
fmt.Fprintf(buf, "// match: %s\n", match)
fmt.Fprintf(buf, "// cond: %s\n", cond)
......@@ -194,7 +207,7 @@ func genRules(arch arch) {
fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
canFail = true
}
if !canFail && i != len(oprules[op])-1 {
if !canFail && i+chunk != len(oprules[op])-1 {
log.Fatalf("unconditional rule %s is followed by other rules", match)
}
......@@ -218,7 +231,7 @@ func genRules(arch arch) {
hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
hasfe := strings.Contains(body, "fe.")
hasts := strings.Contains(body, "types.")
fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op)
fmt.Fprintf(w, "func rewriteValue%s_%s_%d(v *Value) bool {\n", arch.name, op, chunk)
if hasb || hasconfig || hasfe {
fmt.Fprintln(w, "b := v.Block")
fmt.Fprintln(w, "_ = b")
......@@ -238,6 +251,7 @@ func genRules(arch arch) {
fmt.Fprint(w, body)
fmt.Fprintf(w, "}\n")
}
}
// Generate block rewrite function. There are only a few block types
// so we can make this one function with a switch.
......
src/cmd/compile/internal/ssa/rewrite386.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewriteAMD64.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewriteARM.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewriteARM64.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewriteMIPS.go
View file @ fc7b83d1
......@@ -14,499 +14,499 @@ var _ = objabi.GOROOT // in case not otherwise used
func rewriteValueMIPS(v *Value) bool {
switch v.Op {
case OpAdd16:
return rewriteValueMIPS_OpAdd16(v)
return rewriteValueMIPS_OpAdd16_0(v)
case OpAdd32:
return rewriteValueMIPS_OpAdd32(v)
return rewriteValueMIPS_OpAdd32_0(v)
case OpAdd32F:
return rewriteValueMIPS_OpAdd32F(v)
return rewriteValueMIPS_OpAdd32F_0(v)
case OpAdd32withcarry:
return rewriteValueMIPS_OpAdd32withcarry(v)
return rewriteValueMIPS_OpAdd32withcarry_0(v)
case OpAdd64F:
return rewriteValueMIPS_OpAdd64F(v)
return rewriteValueMIPS_OpAdd64F_0(v)
case OpAdd8:
return rewriteValueMIPS_OpAdd8(v)
return rewriteValueMIPS_OpAdd8_0(v)
case OpAddPtr:
return rewriteValueMIPS_OpAddPtr(v)
return rewriteValueMIPS_OpAddPtr_0(v)
case OpAddr:
return rewriteValueMIPS_OpAddr(v)
return rewriteValueMIPS_OpAddr_0(v)
case OpAnd16:
return rewriteValueMIPS_OpAnd16(v)
return rewriteValueMIPS_OpAnd16_0(v)
case OpAnd32:
return rewriteValueMIPS_OpAnd32(v)
return rewriteValueMIPS_OpAnd32_0(v)
case OpAnd8:
return rewriteValueMIPS_OpAnd8(v)
return rewriteValueMIPS_OpAnd8_0(v)
case OpAndB:
return rewriteValueMIPS_OpAndB(v)
return rewriteValueMIPS_OpAndB_0(v)
case OpAtomicAdd32:
return rewriteValueMIPS_OpAtomicAdd32(v)
return rewriteValueMIPS_OpAtomicAdd32_0(v)
case OpAtomicAnd8:
return rewriteValueMIPS_OpAtomicAnd8(v)
return rewriteValueMIPS_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v)
case OpAtomicExchange32:
return rewriteValueMIPS_OpAtomicExchange32(v)
return rewriteValueMIPS_OpAtomicExchange32_0(v)
case OpAtomicLoad32:
return rewriteValueMIPS_OpAtomicLoad32(v)
return rewriteValueMIPS_OpAtomicLoad32_0(v)
case OpAtomicLoadPtr:
return rewriteValueMIPS_OpAtomicLoadPtr(v)
return rewriteValueMIPS_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
return rewriteValueMIPS_OpAtomicOr8(v)
return rewriteValueMIPS_OpAtomicOr8_0(v)
case OpAtomicStore32:
return rewriteValueMIPS_OpAtomicStore32(v)
return rewriteValueMIPS_OpAtomicStore32_0(v)
case OpAtomicStorePtrNoWB:
return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v)
case OpAvg32u:
return rewriteValueMIPS_OpAvg32u(v)
return rewriteValueMIPS_OpAvg32u_0(v)
case OpBitLen32:
return rewriteValueMIPS_OpBitLen32(v)
return rewriteValueMIPS_OpBitLen32_0(v)
case OpClosureCall:
return rewriteValueMIPS_OpClosureCall(v)
return rewriteValueMIPS_OpClosureCall_0(v)
case OpCom16:
return rewriteValueMIPS_OpCom16(v)
return rewriteValueMIPS_OpCom16_0(v)
case OpCom32:
return rewriteValueMIPS_OpCom32(v)
return rewriteValueMIPS_OpCom32_0(v)
case OpCom8:
return rewriteValueMIPS_OpCom8(v)
return rewriteValueMIPS_OpCom8_0(v)
case OpConst16:
return rewriteValueMIPS_OpConst16(v)
return rewriteValueMIPS_OpConst16_0(v)
case OpConst32:
return rewriteValueMIPS_OpConst32(v)
return rewriteValueMIPS_OpConst32_0(v)
case OpConst32F:
return rewriteValueMIPS_OpConst32F(v)
return rewriteValueMIPS_OpConst32F_0(v)
case OpConst64F:
return rewriteValueMIPS_OpConst64F(v)
return rewriteValueMIPS_OpConst64F_0(v)
case OpConst8:
return rewriteValueMIPS_OpConst8(v)
return rewriteValueMIPS_OpConst8_0(v)
case OpConstBool:
return rewriteValueMIPS_OpConstBool(v)
return rewriteValueMIPS_OpConstBool_0(v)
case OpConstNil:
return rewriteValueMIPS_OpConstNil(v)
return rewriteValueMIPS_OpConstNil_0(v)
case OpConvert:
return rewriteValueMIPS_OpConvert(v)
return rewriteValueMIPS_OpConvert_0(v)
case OpCtz32:
return rewriteValueMIPS_OpCtz32(v)
return rewriteValueMIPS_OpCtz32_0(v)
case OpCvt32Fto32:
return rewriteValueMIPS_OpCvt32Fto32(v)
return rewriteValueMIPS_OpCvt32Fto32_0(v)
case OpCvt32Fto64F:
return rewriteValueMIPS_OpCvt32Fto64F(v)
return rewriteValueMIPS_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
return rewriteValueMIPS_OpCvt32to32F(v)
return rewriteValueMIPS_OpCvt32to32F_0(v)
case OpCvt32to64F:
return rewriteValueMIPS_OpCvt32to64F(v)
return rewriteValueMIPS_OpCvt32to64F_0(v)
case OpCvt64Fto32:
return rewriteValueMIPS_OpCvt64Fto32(v)
return rewriteValueMIPS_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
return rewriteValueMIPS_OpCvt64Fto32F(v)
return rewriteValueMIPS_OpCvt64Fto32F_0(v)
case OpDiv16:
return rewriteValueMIPS_OpDiv16(v)
return rewriteValueMIPS_OpDiv16_0(v)
case OpDiv16u:
return rewriteValueMIPS_OpDiv16u(v)
return rewriteValueMIPS_OpDiv16u_0(v)
case OpDiv32:
return rewriteValueMIPS_OpDiv32(v)
return rewriteValueMIPS_OpDiv32_0(v)
case OpDiv32F:
return rewriteValueMIPS_OpDiv32F(v)
return rewriteValueMIPS_OpDiv32F_0(v)
case OpDiv32u:
return rewriteValueMIPS_OpDiv32u(v)
return rewriteValueMIPS_OpDiv32u_0(v)
case OpDiv64F:
return rewriteValueMIPS_OpDiv64F(v)
return rewriteValueMIPS_OpDiv64F_0(v)
case OpDiv8:
return rewriteValueMIPS_OpDiv8(v)
return rewriteValueMIPS_OpDiv8_0(v)
case OpDiv8u:
return rewriteValueMIPS_OpDiv8u(v)
return rewriteValueMIPS_OpDiv8u_0(v)
case OpEq16:
return rewriteValueMIPS_OpEq16(v)
return rewriteValueMIPS_OpEq16_0(v)
case OpEq32:
return rewriteValueMIPS_OpEq32(v)
return rewriteValueMIPS_OpEq32_0(v)
case OpEq32F:
return rewriteValueMIPS_OpEq32F(v)
return rewriteValueMIPS_OpEq32F_0(v)
case OpEq64F:
return rewriteValueMIPS_OpEq64F(v)
return rewriteValueMIPS_OpEq64F_0(v)
case OpEq8:
return rewriteValueMIPS_OpEq8(v)
return rewriteValueMIPS_OpEq8_0(v)
case OpEqB:
return rewriteValueMIPS_OpEqB(v)
return rewriteValueMIPS_OpEqB_0(v)
case OpEqPtr:
return rewriteValueMIPS_OpEqPtr(v)
return rewriteValueMIPS_OpEqPtr_0(v)
case OpGeq16:
return rewriteValueMIPS_OpGeq16(v)
return rewriteValueMIPS_OpGeq16_0(v)
case OpGeq16U:
return rewriteValueMIPS_OpGeq16U(v)
return rewriteValueMIPS_OpGeq16U_0(v)
case OpGeq32:
return rewriteValueMIPS_OpGeq32(v)
return rewriteValueMIPS_OpGeq32_0(v)
case OpGeq32F:
return rewriteValueMIPS_OpGeq32F(v)
return rewriteValueMIPS_OpGeq32F_0(v)
case OpGeq32U:
return rewriteValueMIPS_OpGeq32U(v)
return rewriteValueMIPS_OpGeq32U_0(v)
case OpGeq64F:
return rewriteValueMIPS_OpGeq64F(v)
return rewriteValueMIPS_OpGeq64F_0(v)
case OpGeq8:
return rewriteValueMIPS_OpGeq8(v)
return rewriteValueMIPS_OpGeq8_0(v)
case OpGeq8U:
return rewriteValueMIPS_OpGeq8U(v)
return rewriteValueMIPS_OpGeq8U_0(v)
case OpGetClosurePtr:
return rewriteValueMIPS_OpGetClosurePtr(v)
return rewriteValueMIPS_OpGetClosurePtr_0(v)
case OpGreater16:
return rewriteValueMIPS_OpGreater16(v)
return rewriteValueMIPS_OpGreater16_0(v)
case OpGreater16U:
return rewriteValueMIPS_OpGreater16U(v)
return rewriteValueMIPS_OpGreater16U_0(v)
case OpGreater32:
return rewriteValueMIPS_OpGreater32(v)
return rewriteValueMIPS_OpGreater32_0(v)
case OpGreater32F:
return rewriteValueMIPS_OpGreater32F(v)
return rewriteValueMIPS_OpGreater32F_0(v)
case OpGreater32U:
return rewriteValueMIPS_OpGreater32U(v)
return rewriteValueMIPS_OpGreater32U_0(v)
case OpGreater64F:
return rewriteValueMIPS_OpGreater64F(v)
return rewriteValueMIPS_OpGreater64F_0(v)
case OpGreater8:
return rewriteValueMIPS_OpGreater8(v)
return rewriteValueMIPS_OpGreater8_0(v)
case OpGreater8U:
return rewriteValueMIPS_OpGreater8U(v)
return rewriteValueMIPS_OpGreater8U_0(v)
case OpHmul32:
return rewriteValueMIPS_OpHmul32(v)
return rewriteValueMIPS_OpHmul32_0(v)
case OpHmul32u:
return rewriteValueMIPS_OpHmul32u(v)
return rewriteValueMIPS_OpHmul32u_0(v)
case OpInterCall:
return rewriteValueMIPS_OpInterCall(v)
return rewriteValueMIPS_OpInterCall_0(v)
case OpIsInBounds:
return rewriteValueMIPS_OpIsInBounds(v)
return rewriteValueMIPS_OpIsInBounds_0(v)
case OpIsNonNil:
return rewriteValueMIPS_OpIsNonNil(v)
return rewriteValueMIPS_OpIsNonNil_0(v)
case OpIsSliceInBounds:
return rewriteValueMIPS_OpIsSliceInBounds(v)
return rewriteValueMIPS_OpIsSliceInBounds_0(v)
case OpLeq16:
return rewriteValueMIPS_OpLeq16(v)
return rewriteValueMIPS_OpLeq16_0(v)
case OpLeq16U:
return rewriteValueMIPS_OpLeq16U(v)
return rewriteValueMIPS_OpLeq16U_0(v)
case OpLeq32:
return rewriteValueMIPS_OpLeq32(v)
return rewriteValueMIPS_OpLeq32_0(v)
case OpLeq32F:
return rewriteValueMIPS_OpLeq32F(v)
return rewriteValueMIPS_OpLeq32F_0(v)
case OpLeq32U:
return rewriteValueMIPS_OpLeq32U(v)
return rewriteValueMIPS_OpLeq32U_0(v)
case OpLeq64F:
return rewriteValueMIPS_OpLeq64F(v)
return rewriteValueMIPS_OpLeq64F_0(v)
case OpLeq8:
return rewriteValueMIPS_OpLeq8(v)
return rewriteValueMIPS_OpLeq8_0(v)
case OpLeq8U:
return rewriteValueMIPS_OpLeq8U(v)
return rewriteValueMIPS_OpLeq8U_0(v)
case OpLess16:
return rewriteValueMIPS_OpLess16(v)
return rewriteValueMIPS_OpLess16_0(v)
case OpLess16U:
return rewriteValueMIPS_OpLess16U(v)
return rewriteValueMIPS_OpLess16U_0(v)
case OpLess32:
return rewriteValueMIPS_OpLess32(v)
return rewriteValueMIPS_OpLess32_0(v)
case OpLess32F:
return rewriteValueMIPS_OpLess32F(v)
return rewriteValueMIPS_OpLess32F_0(v)
case OpLess32U:
return rewriteValueMIPS_OpLess32U(v)
return rewriteValueMIPS_OpLess32U_0(v)
case OpLess64F:
return rewriteValueMIPS_OpLess64F(v)
return rewriteValueMIPS_OpLess64F_0(v)
case OpLess8:
return rewriteValueMIPS_OpLess8(v)
return rewriteValueMIPS_OpLess8_0(v)
case OpLess8U:
return rewriteValueMIPS_OpLess8U(v)
return rewriteValueMIPS_OpLess8U_0(v)
case OpLoad:
return rewriteValueMIPS_OpLoad(v)
return rewriteValueMIPS_OpLoad_0(v)
case OpLsh16x16:
return rewriteValueMIPS_OpLsh16x16(v)
return rewriteValueMIPS_OpLsh16x16_0(v)
case OpLsh16x32:
return rewriteValueMIPS_OpLsh16x32(v)
return rewriteValueMIPS_OpLsh16x32_0(v)
case OpLsh16x64:
return rewriteValueMIPS_OpLsh16x64(v)
return rewriteValueMIPS_OpLsh16x64_0(v)
case OpLsh16x8:
return rewriteValueMIPS_OpLsh16x8(v)
return rewriteValueMIPS_OpLsh16x8_0(v)
case OpLsh32x16:
return rewriteValueMIPS_OpLsh32x16(v)
return rewriteValueMIPS_OpLsh32x16_0(v)
case OpLsh32x32:
return rewriteValueMIPS_OpLsh32x32(v)
return rewriteValueMIPS_OpLsh32x32_0(v)
case OpLsh32x64:
return rewriteValueMIPS_OpLsh32x64(v)
return rewriteValueMIPS_OpLsh32x64_0(v)
case OpLsh32x8:
return rewriteValueMIPS_OpLsh32x8(v)
return rewriteValueMIPS_OpLsh32x8_0(v)
case OpLsh8x16:
return rewriteValueMIPS_OpLsh8x16(v)
return rewriteValueMIPS_OpLsh8x16_0(v)
case OpLsh8x32:
return rewriteValueMIPS_OpLsh8x32(v)
return rewriteValueMIPS_OpLsh8x32_0(v)
case OpLsh8x64:
return rewriteValueMIPS_OpLsh8x64(v)
return rewriteValueMIPS_OpLsh8x64_0(v)
case OpLsh8x8:
return rewriteValueMIPS_OpLsh8x8(v)
return rewriteValueMIPS_OpLsh8x8_0(v)
case OpMIPSADD:
return rewriteValueMIPS_OpMIPSADD(v)
return rewriteValueMIPS_OpMIPSADD_0(v)
case OpMIPSADDconst:
return rewriteValueMIPS_OpMIPSADDconst(v)
return rewriteValueMIPS_OpMIPSADDconst_0(v)
case OpMIPSAND:
return rewriteValueMIPS_OpMIPSAND(v)
return rewriteValueMIPS_OpMIPSAND_0(v)
case OpMIPSANDconst:
return rewriteValueMIPS_OpMIPSANDconst(v)
return rewriteValueMIPS_OpMIPSANDconst_0(v)
case OpMIPSCMOVZ:
return rewriteValueMIPS_OpMIPSCMOVZ(v)
return rewriteValueMIPS_OpMIPSCMOVZ_0(v)
case OpMIPSCMOVZzero:
return rewriteValueMIPS_OpMIPSCMOVZzero(v)
return rewriteValueMIPS_OpMIPSCMOVZzero_0(v)
case OpMIPSLoweredAtomicAdd:
return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v)
case OpMIPSLoweredAtomicStore:
return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v)
return rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v)
case OpMIPSMOVBUload:
return rewriteValueMIPS_OpMIPSMOVBUload(v)
return rewriteValueMIPS_OpMIPSMOVBUload_0(v)
case OpMIPSMOVBUreg:
return rewriteValueMIPS_OpMIPSMOVBUreg(v)
return rewriteValueMIPS_OpMIPSMOVBUreg_0(v)
case OpMIPSMOVBload:
return rewriteValueMIPS_OpMIPSMOVBload(v)
return rewriteValueMIPS_OpMIPSMOVBload_0(v)
case OpMIPSMOVBreg:
return rewriteValueMIPS_OpMIPSMOVBreg(v)
return rewriteValueMIPS_OpMIPSMOVBreg_0(v)
case OpMIPSMOVBstore:
return rewriteValueMIPS_OpMIPSMOVBstore(v)
return rewriteValueMIPS_OpMIPSMOVBstore_0(v)
case OpMIPSMOVBstorezero:
return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v)
case OpMIPSMOVDload:
return rewriteValueMIPS_OpMIPSMOVDload(v)
return rewriteValueMIPS_OpMIPSMOVDload_0(v)
case OpMIPSMOVDstore:
return rewriteValueMIPS_OpMIPSMOVDstore(v)
return rewriteValueMIPS_OpMIPSMOVDstore_0(v)
case OpMIPSMOVFload:
return rewriteValueMIPS_OpMIPSMOVFload(v)
return rewriteValueMIPS_OpMIPSMOVFload_0(v)
case OpMIPSMOVFstore:
return rewriteValueMIPS_OpMIPSMOVFstore(v)
return rewriteValueMIPS_OpMIPSMOVFstore_0(v)
case OpMIPSMOVHUload:
return rewriteValueMIPS_OpMIPSMOVHUload(v)
return rewriteValueMIPS_OpMIPSMOVHUload_0(v)
case OpMIPSMOVHUreg:
return rewriteValueMIPS_OpMIPSMOVHUreg(v)
return rewriteValueMIPS_OpMIPSMOVHUreg_0(v)
case OpMIPSMOVHload:
return rewriteValueMIPS_OpMIPSMOVHload(v)
return rewriteValueMIPS_OpMIPSMOVHload_0(v)
case OpMIPSMOVHreg:
return rewriteValueMIPS_OpMIPSMOVHreg(v)
return rewriteValueMIPS_OpMIPSMOVHreg_0(v)
case OpMIPSMOVHstore:
return rewriteValueMIPS_OpMIPSMOVHstore(v)
return rewriteValueMIPS_OpMIPSMOVHstore_0(v)
case OpMIPSMOVHstorezero:
return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v)
case OpMIPSMOVWload:
return rewriteValueMIPS_OpMIPSMOVWload(v)
return rewriteValueMIPS_OpMIPSMOVWload_0(v)
case OpMIPSMOVWreg:
return rewriteValueMIPS_OpMIPSMOVWreg(v)
return rewriteValueMIPS_OpMIPSMOVWreg_0(v)
case OpMIPSMOVWstore:
return rewriteValueMIPS_OpMIPSMOVWstore(v)
return rewriteValueMIPS_OpMIPSMOVWstore_0(v)
case OpMIPSMOVWstorezero:
return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v)
case OpMIPSMUL:
return rewriteValueMIPS_OpMIPSMUL(v)
return rewriteValueMIPS_OpMIPSMUL_0(v)
case OpMIPSNEG:
return rewriteValueMIPS_OpMIPSNEG(v)
return rewriteValueMIPS_OpMIPSNEG_0(v)
case OpMIPSNOR:
return rewriteValueMIPS_OpMIPSNOR(v)
return rewriteValueMIPS_OpMIPSNOR_0(v)
case OpMIPSNORconst:
return rewriteValueMIPS_OpMIPSNORconst(v)
return rewriteValueMIPS_OpMIPSNORconst_0(v)
case OpMIPSOR:
return rewriteValueMIPS_OpMIPSOR(v)
return rewriteValueMIPS_OpMIPSOR_0(v)
case OpMIPSORconst:
return rewriteValueMIPS_OpMIPSORconst(v)
return rewriteValueMIPS_OpMIPSORconst_0(v)
case OpMIPSSGT:
return rewriteValueMIPS_OpMIPSSGT(v)
return rewriteValueMIPS_OpMIPSSGT_0(v)
case OpMIPSSGTU:
return rewriteValueMIPS_OpMIPSSGTU(v)
return rewriteValueMIPS_OpMIPSSGTU_0(v)
case OpMIPSSGTUconst:
return rewriteValueMIPS_OpMIPSSGTUconst(v)
return rewriteValueMIPS_OpMIPSSGTUconst_0(v)
case OpMIPSSGTUzero:
return rewriteValueMIPS_OpMIPSSGTUzero(v)
return rewriteValueMIPS_OpMIPSSGTUzero_0(v)
case OpMIPSSGTconst:
return rewriteValueMIPS_OpMIPSSGTconst(v)
return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v)
case OpMIPSSGTzero:
return rewriteValueMIPS_OpMIPSSGTzero(v)
return rewriteValueMIPS_OpMIPSSGTzero_0(v)
case OpMIPSSLL:
return rewriteValueMIPS_OpMIPSSLL(v)
return rewriteValueMIPS_OpMIPSSLL_0(v)
case OpMIPSSLLconst:
return rewriteValueMIPS_OpMIPSSLLconst(v)
return rewriteValueMIPS_OpMIPSSLLconst_0(v)
case OpMIPSSRA:
return rewriteValueMIPS_OpMIPSSRA(v)
return rewriteValueMIPS_OpMIPSSRA_0(v)
case OpMIPSSRAconst:
return rewriteValueMIPS_OpMIPSSRAconst(v)
return rewriteValueMIPS_OpMIPSSRAconst_0(v)
case OpMIPSSRL:
return rewriteValueMIPS_OpMIPSSRL(v)
return rewriteValueMIPS_OpMIPSSRL_0(v)
case OpMIPSSRLconst:
return rewriteValueMIPS_OpMIPSSRLconst(v)
return rewriteValueMIPS_OpMIPSSRLconst_0(v)
case OpMIPSSUB:
return rewriteValueMIPS_OpMIPSSUB(v)
return rewriteValueMIPS_OpMIPSSUB_0(v)
case OpMIPSSUBconst:
return rewriteValueMIPS_OpMIPSSUBconst(v)
return rewriteValueMIPS_OpMIPSSUBconst_0(v)
case OpMIPSXOR:
return rewriteValueMIPS_OpMIPSXOR(v)
return rewriteValueMIPS_OpMIPSXOR_0(v)
case OpMIPSXORconst:
return rewriteValueMIPS_OpMIPSXORconst(v)
return rewriteValueMIPS_OpMIPSXORconst_0(v)
case OpMod16:
return rewriteValueMIPS_OpMod16(v)
return rewriteValueMIPS_OpMod16_0(v)
case OpMod16u:
return rewriteValueMIPS_OpMod16u(v)
return rewriteValueMIPS_OpMod16u_0(v)
case OpMod32:
return rewriteValueMIPS_OpMod32(v)
return rewriteValueMIPS_OpMod32_0(v)
case OpMod32u:
return rewriteValueMIPS_OpMod32u(v)
return rewriteValueMIPS_OpMod32u_0(v)
case OpMod8:
return rewriteValueMIPS_OpMod8(v)
return rewriteValueMIPS_OpMod8_0(v)
case OpMod8u:
return rewriteValueMIPS_OpMod8u(v)
return rewriteValueMIPS_OpMod8u_0(v)
case OpMove:
return rewriteValueMIPS_OpMove(v)
return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v)
case OpMul16:
return rewriteValueMIPS_OpMul16(v)
return rewriteValueMIPS_OpMul16_0(v)
case OpMul32:
return rewriteValueMIPS_OpMul32(v)
return rewriteValueMIPS_OpMul32_0(v)
case OpMul32F:
return rewriteValueMIPS_OpMul32F(v)
return rewriteValueMIPS_OpMul32F_0(v)
case OpMul32uhilo:
return rewriteValueMIPS_OpMul32uhilo(v)
return rewriteValueMIPS_OpMul32uhilo_0(v)
case OpMul64F:
return rewriteValueMIPS_OpMul64F(v)
return rewriteValueMIPS_OpMul64F_0(v)
case OpMul8:
return rewriteValueMIPS_OpMul8(v)
return rewriteValueMIPS_OpMul8_0(v)
case OpNeg16:
return rewriteValueMIPS_OpNeg16(v)
return rewriteValueMIPS_OpNeg16_0(v)
case OpNeg32:
return rewriteValueMIPS_OpNeg32(v)
return rewriteValueMIPS_OpNeg32_0(v)
case OpNeg32F:
return rewriteValueMIPS_OpNeg32F(v)
return rewriteValueMIPS_OpNeg32F_0(v)
case OpNeg64F:
return rewriteValueMIPS_OpNeg64F(v)
return rewriteValueMIPS_OpNeg64F_0(v)
case OpNeg8:
return rewriteValueMIPS_OpNeg8(v)
return rewriteValueMIPS_OpNeg8_0(v)
case OpNeq16:
return rewriteValueMIPS_OpNeq16(v)
return rewriteValueMIPS_OpNeq16_0(v)
case OpNeq32:
return rewriteValueMIPS_OpNeq32(v)
return rewriteValueMIPS_OpNeq32_0(v)
case OpNeq32F:
return rewriteValueMIPS_OpNeq32F(v)
return rewriteValueMIPS_OpNeq32F_0(v)
case OpNeq64F:
return rewriteValueMIPS_OpNeq64F(v)
return rewriteValueMIPS_OpNeq64F_0(v)
case OpNeq8:
return rewriteValueMIPS_OpNeq8(v)
return rewriteValueMIPS_OpNeq8_0(v)
case OpNeqB:
return rewriteValueMIPS_OpNeqB(v)
return rewriteValueMIPS_OpNeqB_0(v)
case OpNeqPtr:
return rewriteValueMIPS_OpNeqPtr(v)
return rewriteValueMIPS_OpNeqPtr_0(v)
case OpNilCheck:
return rewriteValueMIPS_OpNilCheck(v)
return rewriteValueMIPS_OpNilCheck_0(v)
case OpNot:
return rewriteValueMIPS_OpNot(v)
return rewriteValueMIPS_OpNot_0(v)
case OpOffPtr:
return rewriteValueMIPS_OpOffPtr(v)
return rewriteValueMIPS_OpOffPtr_0(v)
case OpOr16:
return rewriteValueMIPS_OpOr16(v)
return rewriteValueMIPS_OpOr16_0(v)
case OpOr32:
return rewriteValueMIPS_OpOr32(v)
return rewriteValueMIPS_OpOr32_0(v)
case OpOr8:
return rewriteValueMIPS_OpOr8(v)
return rewriteValueMIPS_OpOr8_0(v)
case OpOrB:
return rewriteValueMIPS_OpOrB(v)
return rewriteValueMIPS_OpOrB_0(v)
case OpRound32F:
return rewriteValueMIPS_OpRound32F(v)
return rewriteValueMIPS_OpRound32F_0(v)
case OpRound64F:
return rewriteValueMIPS_OpRound64F(v)
return rewriteValueMIPS_OpRound64F_0(v)
case OpRsh16Ux16:
return rewriteValueMIPS_OpRsh16Ux16(v)
return rewriteValueMIPS_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
return rewriteValueMIPS_OpRsh16Ux32(v)
return rewriteValueMIPS_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
return rewriteValueMIPS_OpRsh16Ux64(v)
return rewriteValueMIPS_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
return rewriteValueMIPS_OpRsh16Ux8(v)
return rewriteValueMIPS_OpRsh16Ux8_0(v)
case OpRsh16x16:
return rewriteValueMIPS_OpRsh16x16(v)
return rewriteValueMIPS_OpRsh16x16_0(v)
case OpRsh16x32:
return rewriteValueMIPS_OpRsh16x32(v)
return rewriteValueMIPS_OpRsh16x32_0(v)
case OpRsh16x64:
return rewriteValueMIPS_OpRsh16x64(v)
return rewriteValueMIPS_OpRsh16x64_0(v)
case OpRsh16x8:
return rewriteValueMIPS_OpRsh16x8(v)
return rewriteValueMIPS_OpRsh16x8_0(v)
case OpRsh32Ux16:
return rewriteValueMIPS_OpRsh32Ux16(v)
return rewriteValueMIPS_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
return rewriteValueMIPS_OpRsh32Ux32(v)
return rewriteValueMIPS_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
return rewriteValueMIPS_OpRsh32Ux64(v)
return rewriteValueMIPS_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
return rewriteValueMIPS_OpRsh32Ux8(v)
return rewriteValueMIPS_OpRsh32Ux8_0(v)
case OpRsh32x16:
return rewriteValueMIPS_OpRsh32x16(v)
return rewriteValueMIPS_OpRsh32x16_0(v)
case OpRsh32x32:
return rewriteValueMIPS_OpRsh32x32(v)
return rewriteValueMIPS_OpRsh32x32_0(v)
case OpRsh32x64:
return rewriteValueMIPS_OpRsh32x64(v)
return rewriteValueMIPS_OpRsh32x64_0(v)
case OpRsh32x8:
return rewriteValueMIPS_OpRsh32x8(v)
return rewriteValueMIPS_OpRsh32x8_0(v)
case OpRsh8Ux16:
return rewriteValueMIPS_OpRsh8Ux16(v)
return rewriteValueMIPS_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
return rewriteValueMIPS_OpRsh8Ux32(v)
return rewriteValueMIPS_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
return rewriteValueMIPS_OpRsh8Ux64(v)
return rewriteValueMIPS_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
return rewriteValueMIPS_OpRsh8Ux8(v)
return rewriteValueMIPS_OpRsh8Ux8_0(v)
case OpRsh8x16:
return rewriteValueMIPS_OpRsh8x16(v)
return rewriteValueMIPS_OpRsh8x16_0(v)
case OpRsh8x32:
return rewriteValueMIPS_OpRsh8x32(v)
return rewriteValueMIPS_OpRsh8x32_0(v)
case OpRsh8x64:
return rewriteValueMIPS_OpRsh8x64(v)
return rewriteValueMIPS_OpRsh8x64_0(v)
case OpRsh8x8:
return rewriteValueMIPS_OpRsh8x8(v)
return rewriteValueMIPS_OpRsh8x8_0(v)
case OpSelect0:
return rewriteValueMIPS_OpSelect0(v)
return rewriteValueMIPS_OpSelect0_0(v) || rewriteValueMIPS_OpSelect0_10(v)
case OpSelect1:
return rewriteValueMIPS_OpSelect1(v)
return rewriteValueMIPS_OpSelect1_0(v) || rewriteValueMIPS_OpSelect1_10(v)
case OpSignExt16to32:
return rewriteValueMIPS_OpSignExt16to32(v)
return rewriteValueMIPS_OpSignExt16to32_0(v)
case OpSignExt8to16:
return rewriteValueMIPS_OpSignExt8to16(v)
return rewriteValueMIPS_OpSignExt8to16_0(v)
case OpSignExt8to32:
return rewriteValueMIPS_OpSignExt8to32(v)
return rewriteValueMIPS_OpSignExt8to32_0(v)
case OpSignmask:
return rewriteValueMIPS_OpSignmask(v)
return rewriteValueMIPS_OpSignmask_0(v)
case OpSlicemask:
return rewriteValueMIPS_OpSlicemask(v)
return rewriteValueMIPS_OpSlicemask_0(v)
case OpSqrt:
return rewriteValueMIPS_OpSqrt(v)
return rewriteValueMIPS_OpSqrt_0(v)
case OpStaticCall:
return rewriteValueMIPS_OpStaticCall(v)
return rewriteValueMIPS_OpStaticCall_0(v)
case OpStore:
return rewriteValueMIPS_OpStore(v)
return rewriteValueMIPS_OpStore_0(v)
case OpSub16:
return rewriteValueMIPS_OpSub16(v)
return rewriteValueMIPS_OpSub16_0(v)
case OpSub32:
return rewriteValueMIPS_OpSub32(v)
return rewriteValueMIPS_OpSub32_0(v)
case OpSub32F:
return rewriteValueMIPS_OpSub32F(v)
return rewriteValueMIPS_OpSub32F_0(v)
case OpSub32withcarry:
return rewriteValueMIPS_OpSub32withcarry(v)
return rewriteValueMIPS_OpSub32withcarry_0(v)
case OpSub64F:
return rewriteValueMIPS_OpSub64F(v)
return rewriteValueMIPS_OpSub64F_0(v)
case OpSub8:
return rewriteValueMIPS_OpSub8(v)
return rewriteValueMIPS_OpSub8_0(v)
case OpSubPtr:
return rewriteValueMIPS_OpSubPtr(v)
return rewriteValueMIPS_OpSubPtr_0(v)
case OpTrunc16to8:
return rewriteValueMIPS_OpTrunc16to8(v)
return rewriteValueMIPS_OpTrunc16to8_0(v)
case OpTrunc32to16:
return rewriteValueMIPS_OpTrunc32to16(v)
return rewriteValueMIPS_OpTrunc32to16_0(v)
case OpTrunc32to8:
return rewriteValueMIPS_OpTrunc32to8(v)
return rewriteValueMIPS_OpTrunc32to8_0(v)
case OpXor16:
return rewriteValueMIPS_OpXor16(v)
return rewriteValueMIPS_OpXor16_0(v)
case OpXor32:
return rewriteValueMIPS_OpXor32(v)
return rewriteValueMIPS_OpXor32_0(v)
case OpXor8:
return rewriteValueMIPS_OpXor8(v)
return rewriteValueMIPS_OpXor8_0(v)
case OpZero:
return rewriteValueMIPS_OpZero(v)
return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v)
case OpZeroExt16to32:
return rewriteValueMIPS_OpZeroExt16to32(v)
return rewriteValueMIPS_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
return rewriteValueMIPS_OpZeroExt8to16(v)
return rewriteValueMIPS_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
return rewriteValueMIPS_OpZeroExt8to32(v)
return rewriteValueMIPS_OpZeroExt8to32_0(v)
case OpZeromask:
return rewriteValueMIPS_OpZeromask(v)
return rewriteValueMIPS_OpZeromask_0(v)
}
return false
}
func rewriteValueMIPS_OpAdd16(v *Value) bool {
func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
......@@ -519,7 +519,7 @@ func rewriteValueMIPS_OpAdd16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAdd32(v *Value) bool {
func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
......@@ -532,7 +532,7 @@ func rewriteValueMIPS_OpAdd32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAdd32F(v *Value) bool {
func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
......@@ -545,7 +545,7 @@ func rewriteValueMIPS_OpAdd32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add32withcarry <t> x y c)
......@@ -565,7 +565,7 @@ func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAdd64F(v *Value) bool {
func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
......@@ -578,7 +578,7 @@ func rewriteValueMIPS_OpAdd64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAdd8(v *Value) bool {
func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
......@@ -591,7 +591,7 @@ func rewriteValueMIPS_OpAdd8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAddPtr(v *Value) bool {
func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
......@@ -604,7 +604,7 @@ func rewriteValueMIPS_OpAddPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAddr(v *Value) bool {
func rewriteValueMIPS_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVWaddr {sym} base)
......@@ -617,7 +617,7 @@ func rewriteValueMIPS_OpAddr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAnd16(v *Value) bool {
func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
......@@ -630,7 +630,7 @@ func rewriteValueMIPS_OpAnd16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAnd32(v *Value) bool {
func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
......@@ -643,7 +643,7 @@ func rewriteValueMIPS_OpAnd32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAnd8(v *Value) bool {
func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
......@@ -656,7 +656,7 @@ func rewriteValueMIPS_OpAnd8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAndB(v *Value) bool {
func rewriteValueMIPS_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
......@@ -669,7 +669,7 @@ func rewriteValueMIPS_OpAndB(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd ptr val mem)
......@@ -684,7 +684,7 @@ func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -797,7 +797,7 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas ptr old new_ mem)
......@@ -814,7 +814,7 @@ func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange ptr val mem)
......@@ -829,7 +829,7 @@ func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LoweredAtomicLoad ptr mem)
......@@ -842,7 +842,7 @@ func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LoweredAtomicLoad ptr mem)
......@@ -855,7 +855,7 @@ func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -931,7 +931,7 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (LoweredAtomicStore ptr val mem)
......@@ -946,7 +946,7 @@ func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (LoweredAtomicStore ptr val mem)
......@@ -961,7 +961,7 @@ func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpAvg32u(v *Value) bool {
func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg32u <t> x y)
......@@ -983,7 +983,7 @@ func rewriteValueMIPS_OpAvg32u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpBitLen32(v *Value) bool {
func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1004,7 +1004,7 @@ func rewriteValueMIPS_OpBitLen32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpClosureCall(v *Value) bool {
func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
......@@ -1021,7 +1021,7 @@ func rewriteValueMIPS_OpClosureCall(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCom16(v *Value) bool {
func rewriteValueMIPS_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NORconst [0] x)
......@@ -1033,7 +1033,7 @@ func rewriteValueMIPS_OpCom16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCom32(v *Value) bool {
func rewriteValueMIPS_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NORconst [0] x)
......@@ -1045,7 +1045,7 @@ func rewriteValueMIPS_OpCom32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCom8(v *Value) bool {
func rewriteValueMIPS_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NORconst [0] x)
......@@ -1057,7 +1057,7 @@ func rewriteValueMIPS_OpCom8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConst16(v *Value) bool {
func rewriteValueMIPS_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVWconst [val])
......@@ -1068,7 +1068,7 @@ func rewriteValueMIPS_OpConst16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConst32(v *Value) bool {
func rewriteValueMIPS_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVWconst [val])
......@@ -1079,7 +1079,7 @@ func rewriteValueMIPS_OpConst32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConst32F(v *Value) bool {
func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
......@@ -1090,7 +1090,7 @@ func rewriteValueMIPS_OpConst32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConst64F(v *Value) bool {
func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
......@@ -1101,7 +1101,7 @@ func rewriteValueMIPS_OpConst64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConst8(v *Value) bool {
func rewriteValueMIPS_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVWconst [val])
......@@ -1112,7 +1112,7 @@ func rewriteValueMIPS_OpConst8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConstBool(v *Value) bool {
func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVWconst [b])
......@@ -1123,7 +1123,7 @@ func rewriteValueMIPS_OpConstBool(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConstNil(v *Value) bool {
func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVWconst [0])
......@@ -1133,7 +1133,7 @@ func rewriteValueMIPS_OpConstNil(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpConvert(v *Value) bool {
func rewriteValueMIPS_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVWconvert x mem)
......@@ -1146,7 +1146,7 @@ func rewriteValueMIPS_OpConvert(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCtz32(v *Value) bool {
func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1175,7 +1175,7 @@ func rewriteValueMIPS_OpCtz32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (TRUNCFW x)
......@@ -1186,7 +1186,7 @@ func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
......@@ -1197,7 +1197,7 @@ func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
......@@ -1208,7 +1208,7 @@ func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
......@@ -1219,7 +1219,7 @@ func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (TRUNCDW x)
......@@ -1230,7 +1230,7 @@ func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
......@@ -1241,7 +1241,7 @@ func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv16(v *Value) bool {
func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1264,7 +1264,7 @@ func rewriteValueMIPS_OpDiv16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv16u(v *Value) bool {
func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1287,7 +1287,7 @@ func rewriteValueMIPS_OpDiv16u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv32(v *Value) bool {
func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1306,7 +1306,7 @@ func rewriteValueMIPS_OpDiv32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv32F(v *Value) bool {
func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
......@@ -1319,7 +1319,7 @@ func rewriteValueMIPS_OpDiv32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv32u(v *Value) bool {
func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1338,7 +1338,7 @@ func rewriteValueMIPS_OpDiv32u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv64F(v *Value) bool {
func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
......@@ -1351,7 +1351,7 @@ func rewriteValueMIPS_OpDiv64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv8(v *Value) bool {
func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1374,7 +1374,7 @@ func rewriteValueMIPS_OpDiv8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpDiv8u(v *Value) bool {
func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1397,7 +1397,7 @@ func rewriteValueMIPS_OpDiv8u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEq16(v *Value) bool {
func rewriteValueMIPS_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1421,7 +1421,7 @@ func rewriteValueMIPS_OpEq16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEq32(v *Value) bool {
func rewriteValueMIPS_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1441,7 +1441,7 @@ func rewriteValueMIPS_OpEq32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEq32F(v *Value) bool {
func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
......@@ -1458,7 +1458,7 @@ func rewriteValueMIPS_OpEq32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEq64F(v *Value) bool {
func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
......@@ -1475,7 +1475,7 @@ func rewriteValueMIPS_OpEq64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEq8(v *Value) bool {
func rewriteValueMIPS_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1499,7 +1499,7 @@ func rewriteValueMIPS_OpEq8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEqB(v *Value) bool {
func rewriteValueMIPS_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1519,7 +1519,7 @@ func rewriteValueMIPS_OpEqB(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpEqPtr(v *Value) bool {
func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1539,7 +1539,7 @@ func rewriteValueMIPS_OpEqPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq16(v *Value) bool {
func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1563,7 +1563,7 @@ func rewriteValueMIPS_OpGeq16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq16U(v *Value) bool {
func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1587,7 +1587,7 @@ func rewriteValueMIPS_OpGeq16U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq32(v *Value) bool {
func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1607,7 +1607,7 @@ func rewriteValueMIPS_OpGeq32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq32F(v *Value) bool {
func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
......@@ -1624,7 +1624,7 @@ func rewriteValueMIPS_OpGeq32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq32U(v *Value) bool {
func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1644,7 +1644,7 @@ func rewriteValueMIPS_OpGeq32U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq64F(v *Value) bool {
func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
......@@ -1661,7 +1661,7 @@ func rewriteValueMIPS_OpGeq64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq8(v *Value) bool {
func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1685,7 +1685,7 @@ func rewriteValueMIPS_OpGeq8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGeq8U(v *Value) bool {
func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1709,7 +1709,7 @@ func rewriteValueMIPS_OpGeq8U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
......@@ -1718,7 +1718,7 @@ func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater16(v *Value) bool {
func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1739,7 +1739,7 @@ func rewriteValueMIPS_OpGreater16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater16U(v *Value) bool {
func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1760,7 +1760,7 @@ func rewriteValueMIPS_OpGreater16U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater32(v *Value) bool {
func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
// match: (Greater32 x y)
// cond:
// result: (SGT x y)
......@@ -1773,7 +1773,7 @@ func rewriteValueMIPS_OpGreater32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater32F(v *Value) bool {
func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
......@@ -1790,7 +1790,7 @@ func rewriteValueMIPS_OpGreater32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater32U(v *Value) bool {
func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
// match: (Greater32U x y)
// cond:
// result: (SGTU x y)
......@@ -1803,7 +1803,7 @@ func rewriteValueMIPS_OpGreater32U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater64F(v *Value) bool {
func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
......@@ -1820,7 +1820,7 @@ func rewriteValueMIPS_OpGreater64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater8(v *Value) bool {
func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1841,7 +1841,7 @@ func rewriteValueMIPS_OpGreater8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpGreater8U(v *Value) bool {
func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1862,7 +1862,7 @@ func rewriteValueMIPS_OpGreater8U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpHmul32(v *Value) bool {
func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1881,7 +1881,7 @@ func rewriteValueMIPS_OpHmul32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpHmul32u(v *Value) bool {
func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1900,7 +1900,7 @@ func rewriteValueMIPS_OpHmul32u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpInterCall(v *Value) bool {
func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
......@@ -1915,7 +1915,7 @@ func rewriteValueMIPS_OpInterCall(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds idx len)
// cond:
// result: (SGTU len idx)
......@@ -1928,7 +1928,7 @@ func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1946,7 +1946,7 @@ func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1966,7 +1966,7 @@ func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq16(v *Value) bool {
func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1990,7 +1990,7 @@ func rewriteValueMIPS_OpLeq16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq16U(v *Value) bool {
func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2014,7 +2014,7 @@ func rewriteValueMIPS_OpLeq16U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq32(v *Value) bool {
func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2034,7 +2034,7 @@ func rewriteValueMIPS_OpLeq32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq32F(v *Value) bool {
func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
......@@ -2051,7 +2051,7 @@ func rewriteValueMIPS_OpLeq32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq32U(v *Value) bool {
func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2071,7 +2071,7 @@ func rewriteValueMIPS_OpLeq32U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq64F(v *Value) bool {
func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
......@@ -2088,7 +2088,7 @@ func rewriteValueMIPS_OpLeq64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq8(v *Value) bool {
func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2112,7 +2112,7 @@ func rewriteValueMIPS_OpLeq8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLeq8U(v *Value) bool {
func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2136,7 +2136,7 @@ func rewriteValueMIPS_OpLeq8U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess16(v *Value) bool {
func rewriteValueMIPS_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2157,7 +2157,7 @@ func rewriteValueMIPS_OpLess16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess16U(v *Value) bool {
func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2178,7 +2178,7 @@ func rewriteValueMIPS_OpLess16U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess32(v *Value) bool {
func rewriteValueMIPS_OpLess32_0(v *Value) bool {
// match: (Less32 x y)
// cond:
// result: (SGT y x)
......@@ -2191,7 +2191,7 @@ func rewriteValueMIPS_OpLess32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess32F(v *Value) bool {
func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
......@@ -2208,7 +2208,7 @@ func rewriteValueMIPS_OpLess32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess32U(v *Value) bool {
func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
// match: (Less32U x y)
// cond:
// result: (SGTU y x)
......@@ -2221,7 +2221,7 @@ func rewriteValueMIPS_OpLess32U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess64F(v *Value) bool {
func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
......@@ -2238,7 +2238,7 @@ func rewriteValueMIPS_OpLess64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess8(v *Value) bool {
func rewriteValueMIPS_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2259,7 +2259,7 @@ func rewriteValueMIPS_OpLess8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLess8U(v *Value) bool {
func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2280,7 +2280,7 @@ func rewriteValueMIPS_OpLess8U(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLoad(v *Value) bool {
func rewriteValueMIPS_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
......@@ -2403,7 +2403,7 @@ func rewriteValueMIPS_OpLoad(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2434,7 +2434,7 @@ func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2461,7 +2461,7 @@ func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint32(c) < 16
// result: (SLLconst x [c])
......@@ -2498,7 +2498,7 @@ func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2529,7 +2529,7 @@ func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2560,7 +2560,7 @@ func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2587,7 +2587,7 @@ func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SLLconst x [c])
......@@ -2624,7 +2624,7 @@ func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2655,7 +2655,7 @@ func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2686,7 +2686,7 @@ func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2713,7 +2713,7 @@ func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint32(c) < 8
// result: (SLLconst x [c])
......@@ -2750,7 +2750,7 @@ func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2781,7 +2781,7 @@ func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
// match: (ADD x (MOVWconst [c]))
// cond:
// result: (ADDconst [c] x)
......@@ -2844,7 +2844,7 @@ func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// cond:
// result: (MOVWaddr [off1+off2] {sym} ptr)
......@@ -2924,7 +2924,7 @@ func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
b := v.Block
_ = b
// match: (AND x (MOVWconst [c]))
......@@ -3028,7 +3028,7 @@ func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVWconst [0])
......@@ -3085,7 +3085,7 @@ func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMOVZ _ b (MOVWconst [0]))
......@@ -3143,7 +3143,7 @@ func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
// match: (CMOVZzero _ (MOVWconst [0]))
// cond:
// result: (MOVWconst [0])
......@@ -3179,7 +3179,7 @@ func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
// match: (LoweredAtomicAdd ptr (MOVWconst [c]) mem)
// cond: is16Bit(c)
// result: (LoweredAtomicAddconst [c] ptr mem)
......@@ -3202,7 +3202,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool {
func rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v *Value) bool {
// match: (LoweredAtomicStore ptr (MOVWconst [0]) mem)
// cond:
// result: (LoweredAtomicStorezero ptr mem)
......@@ -3223,7 +3223,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
......@@ -3296,7 +3296,7 @@ func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBUreg x:(MOVBUload _ _))
......@@ -3379,7 +3379,7 @@ func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBload [off1+off2] {sym} ptr mem)
......@@ -3452,7 +3452,7 @@ func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBreg x:(MOVBload _ _))
......@@ -3538,7 +3538,7 @@ func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
......@@ -3719,7 +3719,7 @@ func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
......@@ -3769,7 +3769,7 @@ func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVDload [off1+off2] {sym} ptr mem)
......@@ -3842,7 +3842,7 @@ func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
......@@ -3896,7 +3896,7 @@ func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVFload [off1+off2] {sym} ptr mem)
......@@ -3969,7 +3969,7 @@ func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
......@@ -4023,7 +4023,7 @@ func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
......@@ -4096,7 +4096,7 @@ func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHUreg x:(MOVBUload _ _))
......@@ -4203,7 +4203,7 @@ func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHload [off1+off2] {sym} ptr mem)
......@@ -4276,7 +4276,7 @@ func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHreg x:(MOVBload _ _))
......@@ -4410,7 +4410,7 @@ func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
......@@ -4549,7 +4549,7 @@ func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
......@@ -4599,7 +4599,7 @@ func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWload [off1+off2] {sym} ptr mem)
......@@ -4672,7 +4672,7 @@ func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
// match: (MOVWreg x)
// cond: x.Uses == 1
// result: (MOVWnop x)
......@@ -4700,7 +4700,7 @@ func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
......@@ -4797,7 +4797,7 @@ func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
......@@ -4847,7 +4847,7 @@ func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
// match: (MUL (MOVWconst [0]) _)
// cond:
// result: (MOVWconst [0])
......@@ -5018,7 +5018,7 @@ func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
// match: (NEG (MOVWconst [c]))
// cond:
// result: (MOVWconst [int64(int32(-c))])
......@@ -5034,7 +5034,7 @@ func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
// match: (NOR x (MOVWconst [c]))
// cond:
// result: (NORconst [c] x)
......@@ -5067,7 +5067,7 @@ func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
// match: (NORconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [^(c|d)])
......@@ -5084,7 +5084,7 @@ func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
b := v.Block
_ = b
// match: (OR x (MOVWconst [c]))
......@@ -5174,7 +5174,7 @@ func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
......@@ -5231,7 +5231,7 @@ func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
// match: (SGT (MOVWconst [c]) x)
// cond:
// result: (SGTconst [c] x)
......@@ -5265,7 +5265,7 @@ func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
// match: (SGTU (MOVWconst [c]) x)
// cond:
// result: (SGTUconst [c] x)
......@@ -5299,7 +5299,7 @@ func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
// match: (SGTUconst [c] (MOVWconst [d]))
// cond: uint32(c)>uint32(d)
// result: (MOVWconst [1])
......@@ -5402,7 +5402,7 @@ func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
// match: (SGTUzero (MOVWconst [d]))
// cond: uint32(d) != 0
// result: (MOVWconst [1])
......@@ -5437,7 +5437,7 @@ func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
// match: (SGTconst [c] (MOVWconst [d]))
// cond: int32(c) > int32(d)
// result: (MOVWconst [1])
......@@ -5600,6 +5600,9 @@ func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
v.AuxInt = 0
return true
}
return false
}
func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
// match: (SGTconst [c] (ANDconst [m] _))
// cond: 0 <= int32(m) && int32(m) < int32(c)
// result: (MOVWconst [1])
......@@ -5636,7 +5639,7 @@ func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
// match: (SGTzero (MOVWconst [d]))
// cond: int32(d) > 0
// result: (MOVWconst [1])
......@@ -5671,7 +5674,7 @@ func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
// match: (SLL _ (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (MOVWconst [0])
......@@ -5705,7 +5708,7 @@ func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))])
......@@ -5722,7 +5725,7 @@ func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
// match: (SRA x (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (SRAconst x [31])
......@@ -5758,7 +5761,7 @@ func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(d)>>uint32(c))])
......@@ -5775,7 +5778,7 @@ func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
// match: (SRL _ (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (MOVWconst [0])
......@@ -5809,7 +5812,7 @@ func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)>>uint32(c))])
......@@ -5826,7 +5829,7 @@ func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
// match: (SUB x (MOVWconst [c]))
// cond:
// result: (SUBconst [c] x)
......@@ -5872,7 +5875,7 @@ func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
......@@ -5934,7 +5937,7 @@ func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
// match: (XOR x (MOVWconst [c]))
// cond:
// result: (XORconst [c] x)
......@@ -5979,7 +5982,7 @@ func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
......@@ -6038,7 +6041,7 @@ func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMod16(v *Value) bool {
func rewriteValueMIPS_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6061,7 +6064,7 @@ func rewriteValueMIPS_OpMod16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMod16u(v *Value) bool {
func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6084,7 +6087,7 @@ func rewriteValueMIPS_OpMod16u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMod32(v *Value) bool {
func rewriteValueMIPS_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6103,7 +6106,7 @@ func rewriteValueMIPS_OpMod32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMod32u(v *Value) bool {
func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6122,7 +6125,7 @@ func rewriteValueMIPS_OpMod32u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMod8(v *Value) bool {
func rewriteValueMIPS_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6145,7 +6148,7 @@ func rewriteValueMIPS_OpMod8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMod8u(v *Value) bool {
func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6168,11 +6171,9 @@ func rewriteValueMIPS_OpMod8u(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMove(v *Value) bool {
func rewriteValueMIPS_OpMove_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
_ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
......@@ -6478,6 +6479,15 @@ func rewriteValueMIPS_OpMove(v *Value) bool {
v.AddArg(v1)
return true
}
return false
}
func rewriteValueMIPS_OpMove_10(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
_ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [6] {t} dst src mem)
// cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
......@@ -6635,7 +6645,7 @@ func rewriteValueMIPS_OpMove(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpMul16(v *Value) bool {
func rewriteValueMIPS_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MUL x y)
......@@ -6648,7 +6658,7 @@ func rewriteValueMIPS_OpMul16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMul32(v *Value) bool {
func rewriteValueMIPS_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MUL x y)
......@@ -6661,7 +6671,7 @@ func rewriteValueMIPS_OpMul32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMul32F(v *Value) bool {
func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
......@@ -6674,7 +6684,7 @@ func rewriteValueMIPS_OpMul32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULTU x y)
......@@ -6687,7 +6697,7 @@ func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMul64F(v *Value) bool {
func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
......@@ -6700,7 +6710,7 @@ func rewriteValueMIPS_OpMul64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpMul8(v *Value) bool {
func rewriteValueMIPS_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MUL x y)
......@@ -6713,7 +6723,7 @@ func rewriteValueMIPS_OpMul8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeg16(v *Value) bool {
func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
......@@ -6724,7 +6734,7 @@ func rewriteValueMIPS_OpNeg16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeg32(v *Value) bool {
func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
......@@ -6735,7 +6745,7 @@ func rewriteValueMIPS_OpNeg32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeg32F(v *Value) bool {
func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
......@@ -6746,7 +6756,7 @@ func rewriteValueMIPS_OpNeg32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeg64F(v *Value) bool {
func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
......@@ -6757,7 +6767,7 @@ func rewriteValueMIPS_OpNeg64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeg8(v *Value) bool {
func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
......@@ -6768,7 +6778,7 @@ func rewriteValueMIPS_OpNeg8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeq16(v *Value) bool {
func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6794,7 +6804,7 @@ func rewriteValueMIPS_OpNeq16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeq32(v *Value) bool {
func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6816,7 +6826,7 @@ func rewriteValueMIPS_OpNeq32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeq32F(v *Value) bool {
func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
......@@ -6833,7 +6843,7 @@ func rewriteValueMIPS_OpNeq32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeq64F(v *Value) bool {
func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
......@@ -6850,7 +6860,7 @@ func rewriteValueMIPS_OpNeq64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeq8(v *Value) bool {
func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6876,7 +6886,7 @@ func rewriteValueMIPS_OpNeq8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeqB(v *Value) bool {
func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
......@@ -6889,7 +6899,7 @@ func rewriteValueMIPS_OpNeqB(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6911,7 +6921,7 @@ func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNilCheck(v *Value) bool {
func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
......@@ -6924,7 +6934,7 @@ func rewriteValueMIPS_OpNilCheck(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpNot(v *Value) bool {
func rewriteValueMIPS_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
......@@ -6936,7 +6946,7 @@ func rewriteValueMIPS_OpNot(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpOffPtr(v *Value) bool {
func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVWaddr [off] ptr)
......@@ -6963,7 +6973,7 @@ func rewriteValueMIPS_OpOffPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpOr16(v *Value) bool {
func rewriteValueMIPS_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
......@@ -6976,7 +6986,7 @@ func rewriteValueMIPS_OpOr16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpOr32(v *Value) bool {
func rewriteValueMIPS_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
......@@ -6989,7 +6999,7 @@ func rewriteValueMIPS_OpOr32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpOr8(v *Value) bool {
func rewriteValueMIPS_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
......@@ -7002,7 +7012,7 @@ func rewriteValueMIPS_OpOr8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpOrB(v *Value) bool {
func rewriteValueMIPS_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
......@@ -7015,7 +7025,7 @@ func rewriteValueMIPS_OpOrB(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRound32F(v *Value) bool {
func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
......@@ -7027,7 +7037,7 @@ func rewriteValueMIPS_OpRound32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRound64F(v *Value) bool {
func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
......@@ -7039,7 +7049,7 @@ func rewriteValueMIPS_OpRound64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7072,7 +7082,7 @@ func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7101,7 +7111,7 @@ func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7145,7 +7155,7 @@ func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7178,7 +7188,7 @@ func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7210,7 +7220,7 @@ func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7238,7 +7248,7 @@ func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7287,7 +7297,7 @@ func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7319,7 +7329,7 @@ func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7350,7 +7360,7 @@ func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7377,7 +7387,7 @@ func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRLconst x [c])
......@@ -7414,7 +7424,7 @@ func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7445,7 +7455,7 @@ func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7475,7 +7485,7 @@ func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7501,7 +7511,7 @@ func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRAconst x [c])
......@@ -7540,7 +7550,7 @@ func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7570,7 +7580,7 @@ func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7603,7 +7613,7 @@ func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7632,7 +7642,7 @@ func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7676,7 +7686,7 @@ func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7709,7 +7719,7 @@ func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7741,7 +7751,7 @@ func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7769,7 +7779,7 @@ func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7818,7 +7828,7 @@ func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7850,7 +7860,7 @@ func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSelect0(v *Value) bool {
func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -8063,6 +8073,9 @@ func rewriteValueMIPS_OpSelect0(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValueMIPS_OpSelect0_10(v *Value) bool {
// match: (Select0 (MULTU (MOVWconst [c]) (MOVWconst [d])))
// cond:
// result: (MOVWconst [(c*d)>>32])
......@@ -8153,7 +8166,7 @@ func rewriteValueMIPS_OpSelect0(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpSelect1(v *Value) bool {
func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -8364,6 +8377,9 @@ func rewriteValueMIPS_OpSelect1(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValueMIPS_OpSelect1_10(v *Value) bool {
// match: (Select1 (MULTU (MOVWconst [c]) (MOVWconst [d])))
// cond:
// result: (MOVWconst [int64(int32(uint32(c)*uint32(d)))])
......@@ -8454,7 +8470,7 @@ func rewriteValueMIPS_OpSelect1(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
......@@ -8465,7 +8481,7 @@ func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
......@@ -8476,7 +8492,7 @@ func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
......@@ -8487,7 +8503,7 @@ func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSignmask(v *Value) bool {
func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SRAconst x [31])
......@@ -8499,7 +8515,7 @@ func rewriteValueMIPS_OpSignmask(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSlicemask(v *Value) bool {
func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
......@@ -8516,7 +8532,7 @@ func rewriteValueMIPS_OpSlicemask(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSqrt(v *Value) bool {
func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTD x)
......@@ -8527,7 +8543,7 @@ func rewriteValueMIPS_OpSqrt(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpStaticCall(v *Value) bool {
func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
......@@ -8542,7 +8558,7 @@ func rewriteValueMIPS_OpStaticCall(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpStore(v *Value) bool {
func rewriteValueMIPS_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
......@@ -8630,7 +8646,7 @@ func rewriteValueMIPS_OpStore(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpSub16(v *Value) bool {
func rewriteValueMIPS_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
......@@ -8643,7 +8659,7 @@ func rewriteValueMIPS_OpSub16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSub32(v *Value) bool {
func rewriteValueMIPS_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
......@@ -8656,7 +8672,7 @@ func rewriteValueMIPS_OpSub32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSub32F(v *Value) bool {
func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
......@@ -8669,7 +8685,7 @@ func rewriteValueMIPS_OpSub32F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub32withcarry <t> x y c)
......@@ -8689,7 +8705,7 @@ func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSub64F(v *Value) bool {
func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
......@@ -8702,7 +8718,7 @@ func rewriteValueMIPS_OpSub64F(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSub8(v *Value) bool {
func rewriteValueMIPS_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
......@@ -8715,7 +8731,7 @@ func rewriteValueMIPS_OpSub8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpSubPtr(v *Value) bool {
func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
......@@ -8728,7 +8744,7 @@ func rewriteValueMIPS_OpSubPtr(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
......@@ -8740,7 +8756,7 @@ func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
......@@ -8752,7 +8768,7 @@ func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
......@@ -8764,7 +8780,7 @@ func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpXor16(v *Value) bool {
func rewriteValueMIPS_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
......@@ -8777,7 +8793,7 @@ func rewriteValueMIPS_OpXor16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpXor32(v *Value) bool {
func rewriteValueMIPS_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
......@@ -8790,7 +8806,7 @@ func rewriteValueMIPS_OpXor32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpXor8(v *Value) bool {
func rewriteValueMIPS_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
......@@ -8803,11 +8819,9 @@ func rewriteValueMIPS_OpXor8(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpZero(v *Value) bool {
func rewriteValueMIPS_OpZero_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
_ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
......@@ -9072,6 +9086,15 @@ func rewriteValueMIPS_OpZero(v *Value) bool {
v.AddArg(v1)
return true
}
return false
}
func rewriteValueMIPS_OpZero_10(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
_ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [12] {t} ptr mem)
// cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem)))
......@@ -9174,7 +9197,7 @@ func rewriteValueMIPS_OpZero(v *Value) bool {
}
return false
}
func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
......@@ -9185,7 +9208,7 @@ func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
......@@ -9196,7 +9219,7 @@ func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
......@@ -9207,7 +9230,7 @@ func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
return true
}
}
func rewriteValueMIPS_OpZeromask(v *Value) bool {
func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......
src/cmd/compile/internal/ssa/rewriteMIPS64.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewritePPC64.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewriteS390X.go
View file @ fc7b83d1
This source diff could not be displayed because it is too large. You can view the blob instead.
src/cmd/compile/internal/ssa/rewritedec.go
View file @ fc7b83d1
......@@ -14,31 +14,31 @@ var _ = objabi.GOROOT // in case not otherwise used
func rewriteValuedec(v *Value) bool {
switch v.Op {
case OpComplexImag:
return rewriteValuedec_OpComplexImag(v)
return rewriteValuedec_OpComplexImag_0(v)
case OpComplexReal:
return rewriteValuedec_OpComplexReal(v)
return rewriteValuedec_OpComplexReal_0(v)
case OpIData:
return rewriteValuedec_OpIData(v)
return rewriteValuedec_OpIData_0(v)
case OpITab:
return rewriteValuedec_OpITab(v)
return rewriteValuedec_OpITab_0(v)
case OpLoad:
return rewriteValuedec_OpLoad(v)
return rewriteValuedec_OpLoad_0(v)
case OpSliceCap:
return rewriteValuedec_OpSliceCap(v)
return rewriteValuedec_OpSliceCap_0(v)
case OpSliceLen:
return rewriteValuedec_OpSliceLen(v)
return rewriteValuedec_OpSliceLen_0(v)
case OpSlicePtr:
return rewriteValuedec_OpSlicePtr(v)
return rewriteValuedec_OpSlicePtr_0(v)
case OpStore:
return rewriteValuedec_OpStore(v)
return rewriteValuedec_OpStore_0(v)
case OpStringLen:
return rewriteValuedec_OpStringLen(v)
return rewriteValuedec_OpStringLen_0(v)
case OpStringPtr:
return rewriteValuedec_OpStringPtr(v)
return rewriteValuedec_OpStringPtr_0(v)
}
return false
}
func rewriteValuedec_OpComplexImag(v *Value) bool {
func rewriteValuedec_OpComplexImag_0(v *Value) bool {
// match: (ComplexImag (ComplexMake _ imag))
// cond:
// result: imag
......@@ -55,7 +55,7 @@ func rewriteValuedec_OpComplexImag(v *Value) bool {
}
return false
}
func rewriteValuedec_OpComplexReal(v *Value) bool {
func rewriteValuedec_OpComplexReal_0(v *Value) bool {
// match: (ComplexReal (ComplexMake real _))
// cond:
// result: real
......@@ -72,7 +72,7 @@ func rewriteValuedec_OpComplexReal(v *Value) bool {
}
return false
}
func rewriteValuedec_OpIData(v *Value) bool {
func rewriteValuedec_OpIData_0(v *Value) bool {
// match: (IData (IMake _ data))
// cond:
// result: data
......@@ -89,7 +89,7 @@ func rewriteValuedec_OpIData(v *Value) bool {
}
return false
}
func rewriteValuedec_OpITab(v *Value) bool {
func rewriteValuedec_OpITab_0(v *Value) bool {
b := v.Block
_ = b
// match: (ITab (IMake itab _))
......@@ -108,7 +108,7 @@ func rewriteValuedec_OpITab(v *Value) bool {
}
return false
}
func rewriteValuedec_OpLoad(v *Value) bool {
func rewriteValuedec_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -244,7 +244,7 @@ func rewriteValuedec_OpLoad(v *Value) bool {
}
return false
}
func rewriteValuedec_OpSliceCap(v *Value) bool {
func rewriteValuedec_OpSliceCap_0(v *Value) bool {
// match: (SliceCap (SliceMake _ _ cap))
// cond:
// result: cap
......@@ -261,7 +261,7 @@ func rewriteValuedec_OpSliceCap(v *Value) bool {
}
return false
}
func rewriteValuedec_OpSliceLen(v *Value) bool {
func rewriteValuedec_OpSliceLen_0(v *Value) bool {
// match: (SliceLen (SliceMake _ len _))
// cond:
// result: len
......@@ -278,7 +278,7 @@ func rewriteValuedec_OpSliceLen(v *Value) bool {
}
return false
}
func rewriteValuedec_OpSlicePtr(v *Value) bool {
func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
// match: (SlicePtr (SliceMake ptr _ _))
// cond:
// result: ptr
......@@ -295,7 +295,7 @@ func rewriteValuedec_OpSlicePtr(v *Value) bool {
}
return false
}
func rewriteValuedec_OpStore(v *Value) bool {
func rewriteValuedec_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -456,7 +456,7 @@ func rewriteValuedec_OpStore(v *Value) bool {
}
return false
}
func rewriteValuedec_OpStringLen(v *Value) bool {
func rewriteValuedec_OpStringLen_0(v *Value) bool {
// match: (StringLen (StringMake _ len))
// cond:
// result: len
......@@ -473,7 +473,7 @@ func rewriteValuedec_OpStringLen(v *Value) bool {
}
return false
}
func rewriteValuedec_OpStringPtr(v *Value) bool {
func rewriteValuedec_OpStringPtr_0(v *Value) bool {
// match: (StringPtr (StringMake ptr _))
// cond:
// result: ptr
......
src/cmd/compile/internal/ssa/rewritedec64.go
View file @ fc7b83d1
......@@ -14,123 +14,123 @@ var _ = objabi.GOROOT // in case not otherwise used
func rewriteValuedec64(v *Value) bool {
switch v.Op {
case OpAdd64:
return rewriteValuedec64_OpAdd64(v)
return rewriteValuedec64_OpAdd64_0(v)
case OpAnd64:
return rewriteValuedec64_OpAnd64(v)
return rewriteValuedec64_OpAnd64_0(v)
case OpArg:
return rewriteValuedec64_OpArg(v)
return rewriteValuedec64_OpArg_0(v)
case OpBitLen64:
return rewriteValuedec64_OpBitLen64(v)
return rewriteValuedec64_OpBitLen64_0(v)
case OpBswap64:
return rewriteValuedec64_OpBswap64(v)
return rewriteValuedec64_OpBswap64_0(v)
case OpCom64:
return rewriteValuedec64_OpCom64(v)
return rewriteValuedec64_OpCom64_0(v)
case OpConst64:
return rewriteValuedec64_OpConst64(v)
return rewriteValuedec64_OpConst64_0(v)
case OpCtz64:
return rewriteValuedec64_OpCtz64(v)
return rewriteValuedec64_OpCtz64_0(v)
case OpEq64:
return rewriteValuedec64_OpEq64(v)
return rewriteValuedec64_OpEq64_0(v)
case OpGeq64:
return rewriteValuedec64_OpGeq64(v)
return rewriteValuedec64_OpGeq64_0(v)
case OpGeq64U:
return rewriteValuedec64_OpGeq64U(v)
return rewriteValuedec64_OpGeq64U_0(v)
case OpGreater64:
return rewriteValuedec64_OpGreater64(v)
return rewriteValuedec64_OpGreater64_0(v)
case OpGreater64U:
return rewriteValuedec64_OpGreater64U(v)
return rewriteValuedec64_OpGreater64U_0(v)
case OpInt64Hi:
return rewriteValuedec64_OpInt64Hi(v)
return rewriteValuedec64_OpInt64Hi_0(v)
case OpInt64Lo:
return rewriteValuedec64_OpInt64Lo(v)
return rewriteValuedec64_OpInt64Lo_0(v)
case OpLeq64:
return rewriteValuedec64_OpLeq64(v)
return rewriteValuedec64_OpLeq64_0(v)
case OpLeq64U:
return rewriteValuedec64_OpLeq64U(v)
return rewriteValuedec64_OpLeq64U_0(v)
case OpLess64:
return rewriteValuedec64_OpLess64(v)
return rewriteValuedec64_OpLess64_0(v)
case OpLess64U:
return rewriteValuedec64_OpLess64U(v)
return rewriteValuedec64_OpLess64U_0(v)
case OpLoad:
return rewriteValuedec64_OpLoad(v)
return rewriteValuedec64_OpLoad_0(v)
case OpLsh16x64:
return rewriteValuedec64_OpLsh16x64(v)
return rewriteValuedec64_OpLsh16x64_0(v)
case OpLsh32x64:
return rewriteValuedec64_OpLsh32x64(v)
return rewriteValuedec64_OpLsh32x64_0(v)
case OpLsh64x16:
return rewriteValuedec64_OpLsh64x16(v)
return rewriteValuedec64_OpLsh64x16_0(v)
case OpLsh64x32:
return rewriteValuedec64_OpLsh64x32(v)
return rewriteValuedec64_OpLsh64x32_0(v)
case OpLsh64x64:
return rewriteValuedec64_OpLsh64x64(v)
return rewriteValuedec64_OpLsh64x64_0(v)
case OpLsh64x8:
return rewriteValuedec64_OpLsh64x8(v)
return rewriteValuedec64_OpLsh64x8_0(v)
case OpLsh8x64:
return rewriteValuedec64_OpLsh8x64(v)
return rewriteValuedec64_OpLsh8x64_0(v)
case OpMul64:
return rewriteValuedec64_OpMul64(v)
return rewriteValuedec64_OpMul64_0(v)
case OpNeg64:
return rewriteValuedec64_OpNeg64(v)
return rewriteValuedec64_OpNeg64_0(v)
case OpNeq64:
return rewriteValuedec64_OpNeq64(v)
return rewriteValuedec64_OpNeq64_0(v)
case OpOr64:
return rewriteValuedec64_OpOr64(v)
return rewriteValuedec64_OpOr64_0(v)
case OpRsh16Ux64:
return rewriteValuedec64_OpRsh16Ux64(v)
return rewriteValuedec64_OpRsh16Ux64_0(v)
case OpRsh16x64:
return rewriteValuedec64_OpRsh16x64(v)
return rewriteValuedec64_OpRsh16x64_0(v)
case OpRsh32Ux64:
return rewriteValuedec64_OpRsh32Ux64(v)
return rewriteValuedec64_OpRsh32Ux64_0(v)
case OpRsh32x64:
return rewriteValuedec64_OpRsh32x64(v)
return rewriteValuedec64_OpRsh32x64_0(v)
case OpRsh64Ux16:
return rewriteValuedec64_OpRsh64Ux16(v)
return rewriteValuedec64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
return rewriteValuedec64_OpRsh64Ux32(v)
return rewriteValuedec64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
return rewriteValuedec64_OpRsh64Ux64(v)
return rewriteValuedec64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
return rewriteValuedec64_OpRsh64Ux8(v)
return rewriteValuedec64_OpRsh64Ux8_0(v)
case OpRsh64x16:
return rewriteValuedec64_OpRsh64x16(v)
return rewriteValuedec64_OpRsh64x16_0(v)
case OpRsh64x32:
return rewriteValuedec64_OpRsh64x32(v)
return rewriteValuedec64_OpRsh64x32_0(v)
case OpRsh64x64:
return rewriteValuedec64_OpRsh64x64(v)
return rewriteValuedec64_OpRsh64x64_0(v)
case OpRsh64x8:
return rewriteValuedec64_OpRsh64x8(v)
return rewriteValuedec64_OpRsh64x8_0(v)
case OpRsh8Ux64:
return rewriteValuedec64_OpRsh8Ux64(v)
return rewriteValuedec64_OpRsh8Ux64_0(v)
case OpRsh8x64:
return rewriteValuedec64_OpRsh8x64(v)
return rewriteValuedec64_OpRsh8x64_0(v)
case OpSignExt16to64:
return rewriteValuedec64_OpSignExt16to64(v)
return rewriteValuedec64_OpSignExt16to64_0(v)
case OpSignExt32to64:
return rewriteValuedec64_OpSignExt32to64(v)
return rewriteValuedec64_OpSignExt32to64_0(v)
case OpSignExt8to64:
return rewriteValuedec64_OpSignExt8to64(v)
return rewriteValuedec64_OpSignExt8to64_0(v)
case OpStore:
return rewriteValuedec64_OpStore(v)
return rewriteValuedec64_OpStore_0(v)
case OpSub64:
return rewriteValuedec64_OpSub64(v)
return rewriteValuedec64_OpSub64_0(v)
case OpTrunc64to16:
return rewriteValuedec64_OpTrunc64to16(v)
return rewriteValuedec64_OpTrunc64to16_0(v)
case OpTrunc64to32:
return rewriteValuedec64_OpTrunc64to32(v)
return rewriteValuedec64_OpTrunc64to32_0(v)
case OpTrunc64to8:
return rewriteValuedec64_OpTrunc64to8(v)
return rewriteValuedec64_OpTrunc64to8_0(v)
case OpXor64:
return rewriteValuedec64_OpXor64(v)
return rewriteValuedec64_OpXor64_0(v)
case OpZeroExt16to64:
return rewriteValuedec64_OpZeroExt16to64(v)
return rewriteValuedec64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
return rewriteValuedec64_OpZeroExt32to64(v)
return rewriteValuedec64_OpZeroExt32to64_0(v)
case OpZeroExt8to64:
return rewriteValuedec64_OpZeroExt8to64(v)
return rewriteValuedec64_OpZeroExt8to64_0(v)
}
return false
}
func rewriteValuedec64_OpAdd64(v *Value) bool {
func rewriteValuedec64_OpAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -173,7 +173,7 @@ func rewriteValuedec64_OpAdd64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpAnd64(v *Value) bool {
func rewriteValuedec64_OpAnd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -204,7 +204,7 @@ func rewriteValuedec64_OpAnd64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpArg(v *Value) bool {
func rewriteValuedec64_OpArg_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -293,7 +293,7 @@ func rewriteValuedec64_OpArg(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpBitLen64(v *Value) bool {
func rewriteValuedec64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -325,7 +325,7 @@ func rewriteValuedec64_OpBitLen64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpBswap64(v *Value) bool {
func rewriteValuedec64_OpBswap64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -349,7 +349,7 @@ func rewriteValuedec64_OpBswap64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpCom64(v *Value) bool {
func rewriteValuedec64_OpCom64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -373,7 +373,7 @@ func rewriteValuedec64_OpCom64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpConst64(v *Value) bool {
func rewriteValuedec64_OpConst64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -416,7 +416,7 @@ func rewriteValuedec64_OpConst64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpCtz64(v *Value) bool {
func rewriteValuedec64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -450,7 +450,7 @@ func rewriteValuedec64_OpCtz64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpEq64(v *Value) bool {
func rewriteValuedec64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -481,7 +481,7 @@ func rewriteValuedec64_OpEq64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpGeq64(v *Value) bool {
func rewriteValuedec64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -522,7 +522,7 @@ func rewriteValuedec64_OpGeq64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpGeq64U(v *Value) bool {
func rewriteValuedec64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -563,7 +563,7 @@ func rewriteValuedec64_OpGeq64U(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpGreater64(v *Value) bool {
func rewriteValuedec64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -604,7 +604,7 @@ func rewriteValuedec64_OpGreater64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpGreater64U(v *Value) bool {
func rewriteValuedec64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -645,7 +645,7 @@ func rewriteValuedec64_OpGreater64U(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpInt64Hi(v *Value) bool {
func rewriteValuedec64_OpInt64Hi_0(v *Value) bool {
// match: (Int64Hi (Int64Make hi _))
// cond:
// result: hi
......@@ -662,7 +662,7 @@ func rewriteValuedec64_OpInt64Hi(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpInt64Lo(v *Value) bool {
func rewriteValuedec64_OpInt64Lo_0(v *Value) bool {
// match: (Int64Lo (Int64Make _ lo))
// cond:
// result: lo
......@@ -679,7 +679,7 @@ func rewriteValuedec64_OpInt64Lo(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLeq64(v *Value) bool {
func rewriteValuedec64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -720,7 +720,7 @@ func rewriteValuedec64_OpLeq64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpLeq64U(v *Value) bool {
func rewriteValuedec64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -761,7 +761,7 @@ func rewriteValuedec64_OpLeq64U(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpLess64(v *Value) bool {
func rewriteValuedec64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -802,7 +802,7 @@ func rewriteValuedec64_OpLess64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpLess64U(v *Value) bool {
func rewriteValuedec64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -843,7 +843,7 @@ func rewriteValuedec64_OpLess64U(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpLoad(v *Value) bool {
func rewriteValuedec64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -948,7 +948,7 @@ func rewriteValuedec64_OpLoad(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh16x64(v *Value) bool {
func rewriteValuedec64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1021,7 +1021,7 @@ func rewriteValuedec64_OpLsh16x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh32x64(v *Value) bool {
func rewriteValuedec64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1094,7 +1094,7 @@ func rewriteValuedec64_OpLsh32x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh64x16(v *Value) bool {
func rewriteValuedec64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1145,7 +1145,7 @@ func rewriteValuedec64_OpLsh64x16(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh64x32(v *Value) bool {
func rewriteValuedec64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1196,7 +1196,7 @@ func rewriteValuedec64_OpLsh64x32(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh64x64(v *Value) bool {
func rewriteValuedec64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1269,7 +1269,7 @@ func rewriteValuedec64_OpLsh64x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh64x8(v *Value) bool {
func rewriteValuedec64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1320,7 +1320,7 @@ func rewriteValuedec64_OpLsh64x8(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpLsh8x64(v *Value) bool {
func rewriteValuedec64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1393,7 +1393,7 @@ func rewriteValuedec64_OpLsh8x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpMul64(v *Value) bool {
func rewriteValuedec64_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1448,7 +1448,7 @@ func rewriteValuedec64_OpMul64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpNeg64(v *Value) bool {
func rewriteValuedec64_OpNeg64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neg64 <t> x)
......@@ -1465,7 +1465,7 @@ func rewriteValuedec64_OpNeg64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpNeq64(v *Value) bool {
func rewriteValuedec64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1496,7 +1496,7 @@ func rewriteValuedec64_OpNeq64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpOr64(v *Value) bool {
func rewriteValuedec64_OpOr64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1527,7 +1527,7 @@ func rewriteValuedec64_OpOr64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1600,7 +1600,7 @@ func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh16x64(v *Value) bool {
func rewriteValuedec64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1676,7 +1676,7 @@ func rewriteValuedec64_OpRsh16x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1749,7 +1749,7 @@ func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh32x64(v *Value) bool {
func rewriteValuedec64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1823,7 +1823,7 @@ func rewriteValuedec64_OpRsh32x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1874,7 +1874,7 @@ func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1925,7 +1925,7 @@ func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -1998,7 +1998,7 @@ func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2049,7 +2049,7 @@ func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64x16(v *Value) bool {
func rewriteValuedec64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2112,7 +2112,7 @@ func rewriteValuedec64_OpRsh64x16(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64x32(v *Value) bool {
func rewriteValuedec64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2173,7 +2173,7 @@ func rewriteValuedec64_OpRsh64x32(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64x64(v *Value) bool {
func rewriteValuedec64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2256,7 +2256,7 @@ func rewriteValuedec64_OpRsh64x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh64x8(v *Value) bool {
func rewriteValuedec64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2319,7 +2319,7 @@ func rewriteValuedec64_OpRsh64x8(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2392,7 +2392,7 @@ func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpRsh8x64(v *Value) bool {
func rewriteValuedec64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2468,7 +2468,7 @@ func rewriteValuedec64_OpRsh8x64(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2485,7 +2485,7 @@ func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2503,7 +2503,7 @@ func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2520,7 +2520,7 @@ func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpStore(v *Value) bool {
func rewriteValuedec64_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -2589,7 +2589,7 @@ func rewriteValuedec64_OpStore(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpSub64(v *Value) bool {
func rewriteValuedec64_OpSub64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2632,7 +2632,7 @@ func rewriteValuedec64_OpSub64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 (Int64Make _ lo))
// cond:
// result: (Trunc32to16 lo)
......@@ -2648,7 +2648,7 @@ func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 (Int64Make _ lo))
// cond:
// result: lo
......@@ -2665,7 +2665,7 @@ func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 (Int64Make _ lo))
// cond:
// result: (Trunc32to8 lo)
......@@ -2681,7 +2681,7 @@ func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
}
return false
}
func rewriteValuedec64_OpXor64(v *Value) bool {
func rewriteValuedec64_OpXor64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2712,7 +2712,7 @@ func rewriteValuedec64_OpXor64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2729,7 +2729,7 @@ func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -2747,7 +2747,7 @@ func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
return true
}
}
func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......
src/cmd/compile/internal/ssa/rewritegeneric.go
View file @ fc7b83d1
......@@ -14,417 +14,417 @@ var _ = objabi.GOROOT // in case not otherwise used
func rewriteValuegeneric(v *Value) bool {
switch v.Op {
case OpAdd16:
return rewriteValuegeneric_OpAdd16(v)
return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v)
case OpAdd32:
return rewriteValuegeneric_OpAdd32(v)
return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v)
case OpAdd32F:
return rewriteValuegeneric_OpAdd32F(v)
return rewriteValuegeneric_OpAdd32F_0(v)
case OpAdd64:
return rewriteValuegeneric_OpAdd64(v)
return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v)
case OpAdd64F:
return rewriteValuegeneric_OpAdd64F(v)
return rewriteValuegeneric_OpAdd64F_0(v)
case OpAdd8:
return rewriteValuegeneric_OpAdd8(v)
return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v)
case OpAddPtr:
return rewriteValuegeneric_OpAddPtr(v)
return rewriteValuegeneric_OpAddPtr_0(v)
case OpAnd16:
return rewriteValuegeneric_OpAnd16(v)
return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v)
case OpAnd32:
return rewriteValuegeneric_OpAnd32(v)
return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v)
case OpAnd64:
return rewriteValuegeneric_OpAnd64(v)
return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v)
case OpAnd8:
return rewriteValuegeneric_OpAnd8(v)
return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v)
case OpArg:
return rewriteValuegeneric_OpArg(v)
return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v)
case OpArraySelect:
return rewriteValuegeneric_OpArraySelect(v)
return rewriteValuegeneric_OpArraySelect_0(v)
case OpCom16:
return rewriteValuegeneric_OpCom16(v)
return rewriteValuegeneric_OpCom16_0(v)
case OpCom32:
return rewriteValuegeneric_OpCom32(v)
return rewriteValuegeneric_OpCom32_0(v)
case OpCom64:
return rewriteValuegeneric_OpCom64(v)
return rewriteValuegeneric_OpCom64_0(v)
case OpCom8:
return rewriteValuegeneric_OpCom8(v)
return rewriteValuegeneric_OpCom8_0(v)
case OpConstInterface:
return rewriteValuegeneric_OpConstInterface(v)
return rewriteValuegeneric_OpConstInterface_0(v)
case OpConstSlice:
return rewriteValuegeneric_OpConstSlice(v)
return rewriteValuegeneric_OpConstSlice_0(v)
case OpConstString:
return rewriteValuegeneric_OpConstString(v)
return rewriteValuegeneric_OpConstString_0(v)
case OpConvert:
return rewriteValuegeneric_OpConvert(v)
return rewriteValuegeneric_OpConvert_0(v)
case OpCvt32Fto64F:
return rewriteValuegeneric_OpCvt32Fto64F(v)
return rewriteValuegeneric_OpCvt32Fto64F_0(v)
case OpCvt64Fto32F:
return rewriteValuegeneric_OpCvt64Fto32F(v)
return rewriteValuegeneric_OpCvt64Fto32F_0(v)
case OpDiv16:
return rewriteValuegeneric_OpDiv16(v)
return rewriteValuegeneric_OpDiv16_0(v)
case OpDiv16u:
return rewriteValuegeneric_OpDiv16u(v)
return rewriteValuegeneric_OpDiv16u_0(v)
case OpDiv32:
return rewriteValuegeneric_OpDiv32(v)
return rewriteValuegeneric_OpDiv32_0(v)
case OpDiv32F:
return rewriteValuegeneric_OpDiv32F(v)
return rewriteValuegeneric_OpDiv32F_0(v)
case OpDiv32u:
return rewriteValuegeneric_OpDiv32u(v)
return rewriteValuegeneric_OpDiv32u_0(v)
case OpDiv64:
return rewriteValuegeneric_OpDiv64(v)
return rewriteValuegeneric_OpDiv64_0(v)
case OpDiv64F:
return rewriteValuegeneric_OpDiv64F(v)
return rewriteValuegeneric_OpDiv64F_0(v)
case OpDiv64u:
return rewriteValuegeneric_OpDiv64u(v)
return rewriteValuegeneric_OpDiv64u_0(v)
case OpDiv8:
return rewriteValuegeneric_OpDiv8(v)
return rewriteValuegeneric_OpDiv8_0(v)
case OpDiv8u:
return rewriteValuegeneric_OpDiv8u(v)
return rewriteValuegeneric_OpDiv8u_0(v)
case OpEq16:
return rewriteValuegeneric_OpEq16(v)
return rewriteValuegeneric_OpEq16_0(v)
case OpEq32:
return rewriteValuegeneric_OpEq32(v)
return rewriteValuegeneric_OpEq32_0(v)
case OpEq64:
return rewriteValuegeneric_OpEq64(v)
return rewriteValuegeneric_OpEq64_0(v)
case OpEq8:
return rewriteValuegeneric_OpEq8(v)
return rewriteValuegeneric_OpEq8_0(v)
case OpEqB:
return rewriteValuegeneric_OpEqB(v)
return rewriteValuegeneric_OpEqB_0(v)
case OpEqInter:
return rewriteValuegeneric_OpEqInter(v)
return rewriteValuegeneric_OpEqInter_0(v)
case OpEqPtr:
return rewriteValuegeneric_OpEqPtr(v)
return rewriteValuegeneric_OpEqPtr_0(v)
case OpEqSlice:
return rewriteValuegeneric_OpEqSlice(v)
return rewriteValuegeneric_OpEqSlice_0(v)
case OpGeq16:
return rewriteValuegeneric_OpGeq16(v)
return rewriteValuegeneric_OpGeq16_0(v)
case OpGeq16U:
return rewriteValuegeneric_OpGeq16U(v)
return rewriteValuegeneric_OpGeq16U_0(v)
case OpGeq32:
return rewriteValuegeneric_OpGeq32(v)
return rewriteValuegeneric_OpGeq32_0(v)
case OpGeq32U:
return rewriteValuegeneric_OpGeq32U(v)
return rewriteValuegeneric_OpGeq32U_0(v)
case OpGeq64:
return rewriteValuegeneric_OpGeq64(v)
return rewriteValuegeneric_OpGeq64_0(v)
case OpGeq64U:
return rewriteValuegeneric_OpGeq64U(v)
return rewriteValuegeneric_OpGeq64U_0(v)
case OpGeq8:
return rewriteValuegeneric_OpGeq8(v)
return rewriteValuegeneric_OpGeq8_0(v)
case OpGeq8U:
return rewriteValuegeneric_OpGeq8U(v)
return rewriteValuegeneric_OpGeq8U_0(v)
case OpGreater16:
return rewriteValuegeneric_OpGreater16(v)
return rewriteValuegeneric_OpGreater16_0(v)
case OpGreater16U:
return rewriteValuegeneric_OpGreater16U(v)
return rewriteValuegeneric_OpGreater16U_0(v)
case OpGreater32:
return rewriteValuegeneric_OpGreater32(v)
return rewriteValuegeneric_OpGreater32_0(v)
case OpGreater32U:
return rewriteValuegeneric_OpGreater32U(v)
return rewriteValuegeneric_OpGreater32U_0(v)
case OpGreater64:
return rewriteValuegeneric_OpGreater64(v)
return rewriteValuegeneric_OpGreater64_0(v)
case OpGreater64U:
return rewriteValuegeneric_OpGreater64U(v)
return rewriteValuegeneric_OpGreater64U_0(v)
case OpGreater8:
return rewriteValuegeneric_OpGreater8(v)
return rewriteValuegeneric_OpGreater8_0(v)
case OpGreater8U:
return rewriteValuegeneric_OpGreater8U(v)
return rewriteValuegeneric_OpGreater8U_0(v)
case OpIMake:
return rewriteValuegeneric_OpIMake(v)
return rewriteValuegeneric_OpIMake_0(v)
case OpInterCall:
return rewriteValuegeneric_OpInterCall(v)
return rewriteValuegeneric_OpInterCall_0(v)
case OpIsInBounds:
return rewriteValuegeneric_OpIsInBounds(v)
return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v)
case OpIsNonNil:
return rewriteValuegeneric_OpIsNonNil(v)
return rewriteValuegeneric_OpIsNonNil_0(v)
case OpIsSliceInBounds:
return rewriteValuegeneric_OpIsSliceInBounds(v)
return rewriteValuegeneric_OpIsSliceInBounds_0(v)
case OpLeq16:
return rewriteValuegeneric_OpLeq16(v)
return rewriteValuegeneric_OpLeq16_0(v)
case OpLeq16U:
return rewriteValuegeneric_OpLeq16U(v)
return rewriteValuegeneric_OpLeq16U_0(v)
case OpLeq32:
return rewriteValuegeneric_OpLeq32(v)
return rewriteValuegeneric_OpLeq32_0(v)
case OpLeq32U:
return rewriteValuegeneric_OpLeq32U(v)
return rewriteValuegeneric_OpLeq32U_0(v)
case OpLeq64:
return rewriteValuegeneric_OpLeq64(v)
return rewriteValuegeneric_OpLeq64_0(v)
case OpLeq64U:
return rewriteValuegeneric_OpLeq64U(v)
return rewriteValuegeneric_OpLeq64U_0(v)
case OpLeq8:
return rewriteValuegeneric_OpLeq8(v)
return rewriteValuegeneric_OpLeq8_0(v)
case OpLeq8U:
return rewriteValuegeneric_OpLeq8U(v)
return rewriteValuegeneric_OpLeq8U_0(v)
case OpLess16:
return rewriteValuegeneric_OpLess16(v)
return rewriteValuegeneric_OpLess16_0(v)
case OpLess16U:
return rewriteValuegeneric_OpLess16U(v)
return rewriteValuegeneric_OpLess16U_0(v)
case OpLess32:
return rewriteValuegeneric_OpLess32(v)
return rewriteValuegeneric_OpLess32_0(v)
case OpLess32U:
return rewriteValuegeneric_OpLess32U(v)
return rewriteValuegeneric_OpLess32U_0(v)
case OpLess64:
return rewriteValuegeneric_OpLess64(v)
return rewriteValuegeneric_OpLess64_0(v)
case OpLess64U:
return rewriteValuegeneric_OpLess64U(v)
return rewriteValuegeneric_OpLess64U_0(v)
case OpLess8:
return rewriteValuegeneric_OpLess8(v)
return rewriteValuegeneric_OpLess8_0(v)
case OpLess8U:
return rewriteValuegeneric_OpLess8U(v)
return rewriteValuegeneric_OpLess8U_0(v)
case OpLoad:
return rewriteValuegeneric_OpLoad(v)
return rewriteValuegeneric_OpLoad_0(v)
case OpLsh16x16:
return rewriteValuegeneric_OpLsh16x16(v)
return rewriteValuegeneric_OpLsh16x16_0(v)
case OpLsh16x32:
return rewriteValuegeneric_OpLsh16x32(v)
return rewriteValuegeneric_OpLsh16x32_0(v)
case OpLsh16x64:
return rewriteValuegeneric_OpLsh16x64(v)
return rewriteValuegeneric_OpLsh16x64_0(v)
case OpLsh16x8:
return rewriteValuegeneric_OpLsh16x8(v)
return rewriteValuegeneric_OpLsh16x8_0(v)
case OpLsh32x16:
return rewriteValuegeneric_OpLsh32x16(v)
return rewriteValuegeneric_OpLsh32x16_0(v)
case OpLsh32x32:
return rewriteValuegeneric_OpLsh32x32(v)
return rewriteValuegeneric_OpLsh32x32_0(v)
case OpLsh32x64:
return rewriteValuegeneric_OpLsh32x64(v)
return rewriteValuegeneric_OpLsh32x64_0(v)
case OpLsh32x8:
return rewriteValuegeneric_OpLsh32x8(v)
return rewriteValuegeneric_OpLsh32x8_0(v)
case OpLsh64x16:
return rewriteValuegeneric_OpLsh64x16(v)
return rewriteValuegeneric_OpLsh64x16_0(v)
case OpLsh64x32:
return rewriteValuegeneric_OpLsh64x32(v)
return rewriteValuegeneric_OpLsh64x32_0(v)
case OpLsh64x64:
return rewriteValuegeneric_OpLsh64x64(v)
return rewriteValuegeneric_OpLsh64x64_0(v)
case OpLsh64x8:
return rewriteValuegeneric_OpLsh64x8(v)
return rewriteValuegeneric_OpLsh64x8_0(v)
case OpLsh8x16:
return rewriteValuegeneric_OpLsh8x16(v)
return rewriteValuegeneric_OpLsh8x16_0(v)
case OpLsh8x32:
return rewriteValuegeneric_OpLsh8x32(v)
return rewriteValuegeneric_OpLsh8x32_0(v)
case OpLsh8x64:
return rewriteValuegeneric_OpLsh8x64(v)
return rewriteValuegeneric_OpLsh8x64_0(v)
case OpLsh8x8:
return rewriteValuegeneric_OpLsh8x8(v)
return rewriteValuegeneric_OpLsh8x8_0(v)
case OpMod16:
return rewriteValuegeneric_OpMod16(v)
return rewriteValuegeneric_OpMod16_0(v)
case OpMod16u:
return rewriteValuegeneric_OpMod16u(v)
return rewriteValuegeneric_OpMod16u_0(v)
case OpMod32:
return rewriteValuegeneric_OpMod32(v)
return rewriteValuegeneric_OpMod32_0(v)
case OpMod32u:
return rewriteValuegeneric_OpMod32u(v)
return rewriteValuegeneric_OpMod32u_0(v)
case OpMod64:
return rewriteValuegeneric_OpMod64(v)
return rewriteValuegeneric_OpMod64_0(v)
case OpMod64u:
return rewriteValuegeneric_OpMod64u(v)
return rewriteValuegeneric_OpMod64u_0(v)
case OpMod8:
return rewriteValuegeneric_OpMod8(v)
return rewriteValuegeneric_OpMod8_0(v)
case OpMod8u:
return rewriteValuegeneric_OpMod8u(v)
return rewriteValuegeneric_OpMod8u_0(v)
case OpMul16:
return rewriteValuegeneric_OpMul16(v)
return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v)
case OpMul32:
return rewriteValuegeneric_OpMul32(v)
return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v)
case OpMul32F:
return rewriteValuegeneric_OpMul32F(v)
return rewriteValuegeneric_OpMul32F_0(v)
case OpMul64:
return rewriteValuegeneric_OpMul64(v)
return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v)
case OpMul64F:
return rewriteValuegeneric_OpMul64F(v)
return rewriteValuegeneric_OpMul64F_0(v)
case OpMul8:
return rewriteValuegeneric_OpMul8(v)
return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v)
case OpNeg16:
return rewriteValuegeneric_OpNeg16(v)
return rewriteValuegeneric_OpNeg16_0(v)
case OpNeg32:
return rewriteValuegeneric_OpNeg32(v)
return rewriteValuegeneric_OpNeg32_0(v)
case OpNeg32F:
return rewriteValuegeneric_OpNeg32F(v)
return rewriteValuegeneric_OpNeg32F_0(v)
case OpNeg64:
return rewriteValuegeneric_OpNeg64(v)
return rewriteValuegeneric_OpNeg64_0(v)
case OpNeg64F:
return rewriteValuegeneric_OpNeg64F(v)
return rewriteValuegeneric_OpNeg64F_0(v)
case OpNeg8:
return rewriteValuegeneric_OpNeg8(v)
return rewriteValuegeneric_OpNeg8_0(v)
case OpNeq16:
return rewriteValuegeneric_OpNeq16(v)
return rewriteValuegeneric_OpNeq16_0(v)
case OpNeq32:
return rewriteValuegeneric_OpNeq32(v)
return rewriteValuegeneric_OpNeq32_0(v)
case OpNeq64:
return rewriteValuegeneric_OpNeq64(v)
return rewriteValuegeneric_OpNeq64_0(v)
case OpNeq8:
return rewriteValuegeneric_OpNeq8(v)
return rewriteValuegeneric_OpNeq8_0(v)
case OpNeqB:
return rewriteValuegeneric_OpNeqB(v)
return rewriteValuegeneric_OpNeqB_0(v)
case OpNeqInter:
return rewriteValuegeneric_OpNeqInter(v)
return rewriteValuegeneric_OpNeqInter_0(v)
case OpNeqPtr:
return rewriteValuegeneric_OpNeqPtr(v)
return rewriteValuegeneric_OpNeqPtr_0(v)
case OpNeqSlice:
return rewriteValuegeneric_OpNeqSlice(v)
return rewriteValuegeneric_OpNeqSlice_0(v)
case OpNilCheck:
return rewriteValuegeneric_OpNilCheck(v)
return rewriteValuegeneric_OpNilCheck_0(v)
case OpNot:
return rewriteValuegeneric_OpNot(v)
return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
case OpOffPtr:
return rewriteValuegeneric_OpOffPtr(v)
return rewriteValuegeneric_OpOffPtr_0(v)
case OpOr16:
return rewriteValuegeneric_OpOr16(v)
return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v)
case OpOr32:
return rewriteValuegeneric_OpOr32(v)
return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v)
case OpOr64:
return rewriteValuegeneric_OpOr64(v)
return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v)
case OpOr8:
return rewriteValuegeneric_OpOr8(v)
return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v)
case OpPhi:
return rewriteValuegeneric_OpPhi(v)
return rewriteValuegeneric_OpPhi_0(v)
case OpPtrIndex:
return rewriteValuegeneric_OpPtrIndex(v)
return rewriteValuegeneric_OpPtrIndex_0(v)
case OpRound32F:
return rewriteValuegeneric_OpRound32F(v)
return rewriteValuegeneric_OpRound32F_0(v)
case OpRound64F:
return rewriteValuegeneric_OpRound64F(v)
return rewriteValuegeneric_OpRound64F_0(v)
case OpRsh16Ux16:
return rewriteValuegeneric_OpRsh16Ux16(v)
return rewriteValuegeneric_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
return rewriteValuegeneric_OpRsh16Ux32(v)
return rewriteValuegeneric_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
return rewriteValuegeneric_OpRsh16Ux64(v)
return rewriteValuegeneric_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
return rewriteValuegeneric_OpRsh16Ux8(v)
return rewriteValuegeneric_OpRsh16Ux8_0(v)
case OpRsh16x16:
return rewriteValuegeneric_OpRsh16x16(v)
return rewriteValuegeneric_OpRsh16x16_0(v)
case OpRsh16x32:
return rewriteValuegeneric_OpRsh16x32(v)
return rewriteValuegeneric_OpRsh16x32_0(v)
case OpRsh16x64:
return rewriteValuegeneric_OpRsh16x64(v)
return rewriteValuegeneric_OpRsh16x64_0(v)
case OpRsh16x8:
return rewriteValuegeneric_OpRsh16x8(v)
return rewriteValuegeneric_OpRsh16x8_0(v)
case OpRsh32Ux16:
return rewriteValuegeneric_OpRsh32Ux16(v)
return rewriteValuegeneric_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
return rewriteValuegeneric_OpRsh32Ux32(v)
return rewriteValuegeneric_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
return rewriteValuegeneric_OpRsh32Ux64(v)
return rewriteValuegeneric_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
return rewriteValuegeneric_OpRsh32Ux8(v)
return rewriteValuegeneric_OpRsh32Ux8_0(v)
case OpRsh32x16:
return rewriteValuegeneric_OpRsh32x16(v)
return rewriteValuegeneric_OpRsh32x16_0(v)
case OpRsh32x32:
return rewriteValuegeneric_OpRsh32x32(v)
return rewriteValuegeneric_OpRsh32x32_0(v)
case OpRsh32x64:
return rewriteValuegeneric_OpRsh32x64(v)
return rewriteValuegeneric_OpRsh32x64_0(v)
case OpRsh32x8:
return rewriteValuegeneric_OpRsh32x8(v)
return rewriteValuegeneric_OpRsh32x8_0(v)
case OpRsh64Ux16:
return rewriteValuegeneric_OpRsh64Ux16(v)
return rewriteValuegeneric_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
return rewriteValuegeneric_OpRsh64Ux32(v)
return rewriteValuegeneric_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
return rewriteValuegeneric_OpRsh64Ux64(v)
return rewriteValuegeneric_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
return rewriteValuegeneric_OpRsh64Ux8(v)
return rewriteValuegeneric_OpRsh64Ux8_0(v)
case OpRsh64x16:
return rewriteValuegeneric_OpRsh64x16(v)
return rewriteValuegeneric_OpRsh64x16_0(v)
case OpRsh64x32:
return rewriteValuegeneric_OpRsh64x32(v)
return rewriteValuegeneric_OpRsh64x32_0(v)
case OpRsh64x64:
return rewriteValuegeneric_OpRsh64x64(v)
return rewriteValuegeneric_OpRsh64x64_0(v)
case OpRsh64x8:
return rewriteValuegeneric_OpRsh64x8(v)
return rewriteValuegeneric_OpRsh64x8_0(v)
case OpRsh8Ux16:
return rewriteValuegeneric_OpRsh8Ux16(v)
return rewriteValuegeneric_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
return rewriteValuegeneric_OpRsh8Ux32(v)
return rewriteValuegeneric_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
return rewriteValuegeneric_OpRsh8Ux64(v)
return rewriteValuegeneric_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
return rewriteValuegeneric_OpRsh8Ux8(v)
return rewriteValuegeneric_OpRsh8Ux8_0(v)
case OpRsh8x16:
return rewriteValuegeneric_OpRsh8x16(v)
return rewriteValuegeneric_OpRsh8x16_0(v)
case OpRsh8x32:
return rewriteValuegeneric_OpRsh8x32(v)
return rewriteValuegeneric_OpRsh8x32_0(v)
case OpRsh8x64:
return rewriteValuegeneric_OpRsh8x64(v)
return rewriteValuegeneric_OpRsh8x64_0(v)
case OpRsh8x8:
return rewriteValuegeneric_OpRsh8x8(v)
return rewriteValuegeneric_OpRsh8x8_0(v)
case OpSignExt16to32:
return rewriteValuegeneric_OpSignExt16to32(v)
return rewriteValuegeneric_OpSignExt16to32_0(v)
case OpSignExt16to64:
return rewriteValuegeneric_OpSignExt16to64(v)
return rewriteValuegeneric_OpSignExt16to64_0(v)
case OpSignExt32to64:
return rewriteValuegeneric_OpSignExt32to64(v)
return rewriteValuegeneric_OpSignExt32to64_0(v)
case OpSignExt8to16:
return rewriteValuegeneric_OpSignExt8to16(v)
return rewriteValuegeneric_OpSignExt8to16_0(v)
case OpSignExt8to32:
return rewriteValuegeneric_OpSignExt8to32(v)
return rewriteValuegeneric_OpSignExt8to32_0(v)
case OpSignExt8to64:
return rewriteValuegeneric_OpSignExt8to64(v)
return rewriteValuegeneric_OpSignExt8to64_0(v)
case OpSliceCap:
return rewriteValuegeneric_OpSliceCap(v)
return rewriteValuegeneric_OpSliceCap_0(v)
case OpSliceLen:
return rewriteValuegeneric_OpSliceLen(v)
return rewriteValuegeneric_OpSliceLen_0(v)
case OpSlicePtr:
return rewriteValuegeneric_OpSlicePtr(v)
return rewriteValuegeneric_OpSlicePtr_0(v)
case OpSlicemask:
return rewriteValuegeneric_OpSlicemask(v)
return rewriteValuegeneric_OpSlicemask_0(v)
case OpSqrt:
return rewriteValuegeneric_OpSqrt(v)
return rewriteValuegeneric_OpSqrt_0(v)
case OpStore:
return rewriteValuegeneric_OpStore(v)
return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v)
case OpStringLen:
return rewriteValuegeneric_OpStringLen(v)
return rewriteValuegeneric_OpStringLen_0(v)
case OpStringPtr:
return rewriteValuegeneric_OpStringPtr(v)
return rewriteValuegeneric_OpStringPtr_0(v)
case OpStructSelect:
return rewriteValuegeneric_OpStructSelect(v)
return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
case OpSub16:
return rewriteValuegeneric_OpSub16(v)
return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v)
case OpSub32:
return rewriteValuegeneric_OpSub32(v)
return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v)
case OpSub32F:
return rewriteValuegeneric_OpSub32F(v)
return rewriteValuegeneric_OpSub32F_0(v)
case OpSub64:
return rewriteValuegeneric_OpSub64(v)
return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v)
case OpSub64F:
return rewriteValuegeneric_OpSub64F(v)
return rewriteValuegeneric_OpSub64F_0(v)
case OpSub8:
return rewriteValuegeneric_OpSub8(v)
return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v)
case OpTrunc16to8:
return rewriteValuegeneric_OpTrunc16to8(v)
return rewriteValuegeneric_OpTrunc16to8_0(v)
case OpTrunc32to16:
return rewriteValuegeneric_OpTrunc32to16(v)
return rewriteValuegeneric_OpTrunc32to16_0(v)
case OpTrunc32to8:
return rewriteValuegeneric_OpTrunc32to8(v)
return rewriteValuegeneric_OpTrunc32to8_0(v)
case OpTrunc64to16:
return rewriteValuegeneric_OpTrunc64to16(v)
return rewriteValuegeneric_OpTrunc64to16_0(v)
case OpTrunc64to32:
return rewriteValuegeneric_OpTrunc64to32(v)
return rewriteValuegeneric_OpTrunc64to32_0(v)
case OpTrunc64to8:
return rewriteValuegeneric_OpTrunc64to8(v)
return rewriteValuegeneric_OpTrunc64to8_0(v)
case OpXor16:
return rewriteValuegeneric_OpXor16(v)
return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v)
case OpXor32:
return rewriteValuegeneric_OpXor32(v)
return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v)
case OpXor64:
return rewriteValuegeneric_OpXor64(v)
return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v)
case OpXor8:
return rewriteValuegeneric_OpXor8(v)
return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v)
case OpZero:
return rewriteValuegeneric_OpZero(v)
return rewriteValuegeneric_OpZero_0(v)
case OpZeroExt16to32:
return rewriteValuegeneric_OpZeroExt16to32(v)
return rewriteValuegeneric_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
return rewriteValuegeneric_OpZeroExt16to64(v)
return rewriteValuegeneric_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
return rewriteValuegeneric_OpZeroExt32to64(v)
return rewriteValuegeneric_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
return rewriteValuegeneric_OpZeroExt8to16(v)
return rewriteValuegeneric_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
return rewriteValuegeneric_OpZeroExt8to32(v)
return rewriteValuegeneric_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
return rewriteValuegeneric_OpZeroExt8to64(v)
return rewriteValuegeneric_OpZeroExt8to64_0(v)
}
return false
}
func rewriteValuegeneric_OpAdd16(v *Value) bool {
func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add16 (Const16 [c]) (Const16 [d]))
......@@ -641,6 +641,11 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpAdd16_10(v *Value) bool {
b := v.Block
_ = b
// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
// cond: (z.Op != OpConst16 && x.Op != OpConst16)
// result: (Add16 i (Sub16 <t> x z))
......@@ -909,6 +914,11 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpAdd16_20(v *Value) bool {
b := v.Block
_ = b
// match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
// cond:
// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
......@@ -1091,7 +1101,7 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAdd32(v *Value) bool {
func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add32 (Const32 [c]) (Const32 [d]))
......@@ -1308,6 +1318,11 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpAdd32_10(v *Value) bool {
b := v.Block
_ = b
// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
// cond: (z.Op != OpConst32 && x.Op != OpConst32)
// result: (Add32 i (Sub32 <t> x z))
......@@ -1576,6 +1591,11 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpAdd32_20(v *Value) bool {
b := v.Block
_ = b
// match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
......@@ -1758,7 +1778,7 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAdd32F(v *Value) bool {
func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
// match: (Add32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))])
......@@ -1831,7 +1851,7 @@ func rewriteValuegeneric_OpAdd32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAdd64(v *Value) bool {
func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add64 (Const64 [c]) (Const64 [d]))
......@@ -2048,6 +2068,11 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpAdd64_10(v *Value) bool {
b := v.Block
_ = b
// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
// cond: (z.Op != OpConst64 && x.Op != OpConst64)
// result: (Add64 i (Sub64 <t> x z))
......@@ -2316,6 +2341,11 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpAdd64_20(v *Value) bool {
b := v.Block
_ = b
// match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
// cond:
// result: (Add64 (Const64 <t> [c+d]) x)
......@@ -2498,7 +2528,7 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAdd64F(v *Value) bool {
func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
// match: (Add64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) + i2f(d))])
......@@ -2571,7 +2601,7 @@ func rewriteValuegeneric_OpAdd64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAdd8(v *Value) bool {
func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add8 (Const8 [c]) (Const8 [d]))
......@@ -2788,6 +2818,11 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpAdd8_10(v *Value) bool {
b := v.Block
_ = b
// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
// cond: (z.Op != OpConst8 && x.Op != OpConst8)
// result: (Add8 i (Sub8 <t> x z))
......@@ -3056,6 +3091,11 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpAdd8_20(v *Value) bool {
b := v.Block
_ = b
// match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
// cond:
// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
......@@ -3238,7 +3278,7 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAddPtr(v *Value) bool {
func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
// match: (AddPtr <t> x (Const64 [c]))
// cond:
// result: (OffPtr <t> x [c])
......@@ -3275,9 +3315,7 @@ func rewriteValuegeneric_OpAddPtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAnd16(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
// match: (And16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [int64(int16(c&d))])
......@@ -3445,6 +3483,11 @@ func rewriteValuegeneric_OpAnd16(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpAnd16_10(v *Value) bool {
b := v.Block
_ = b
// match: (And16 (And16 y x) x)
// cond:
// result: (And16 x y)
......@@ -3689,9 +3732,7 @@ func rewriteValuegeneric_OpAnd16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAnd32(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
// match: (And32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [int64(int32(c&d))])
......@@ -3859,6 +3900,11 @@ func rewriteValuegeneric_OpAnd32(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpAnd32_10(v *Value) bool {
b := v.Block
_ = b
// match: (And32 (And32 y x) x)
// cond:
// result: (And32 x y)
......@@ -4103,9 +4149,7 @@ func rewriteValuegeneric_OpAnd32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAnd64(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
// match: (And64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c&d])
......@@ -4273,6 +4317,11 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpAnd64_10(v *Value) bool {
b := v.Block
_ = b
// match: (And64 (And64 y x) x)
// cond:
// result: (And64 x y)
......@@ -4529,6 +4578,11 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpAnd64_20(v *Value) bool {
b := v.Block
_ = b
// match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d])))
// cond:
// result: (And64 (Const64 <t> [c&d]) x)
......@@ -4621,9 +4675,7 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpAnd8(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
// match: (And8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [int64(int8(c&d))])
......@@ -4791,6 +4843,11 @@ func rewriteValuegeneric_OpAnd8(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpAnd8_10(v *Value) bool {
b := v.Block
_ = b
// match: (And8 (And8 y x) x)
// cond:
// result: (And8 x y)
......@@ -5035,7 +5092,7 @@ func rewriteValuegeneric_OpAnd8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpArg(v *Value) bool {
func rewriteValuegeneric_OpArg_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -5251,6 +5308,13 @@ func rewriteValuegeneric_OpArg(v *Value) bool {
v.AddArg(v3)
return true
}
return false
}
func rewriteValuegeneric_OpArg_10(v *Value) bool {
b := v.Block
_ = b
fe := b.Func.fe
_ = fe
// match: (Arg <t>)
// cond: t.IsArray() && t.NumElem() == 0
// result: (ArrayMake0)
......@@ -5281,7 +5345,7 @@ func rewriteValuegeneric_OpArg(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpArraySelect(v *Value) bool {
func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
// match: (ArraySelect (ArrayMake1 x))
// cond:
// result: x
......@@ -5332,7 +5396,7 @@ func rewriteValuegeneric_OpArraySelect(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCom16(v *Value) bool {
func rewriteValuegeneric_OpCom16_0(v *Value) bool {
// match: (Com16 (Com16 x))
// cond:
// result: x
......@@ -5349,7 +5413,7 @@ func rewriteValuegeneric_OpCom16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCom32(v *Value) bool {
func rewriteValuegeneric_OpCom32_0(v *Value) bool {
// match: (Com32 (Com32 x))
// cond:
// result: x
......@@ -5366,7 +5430,7 @@ func rewriteValuegeneric_OpCom32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCom64(v *Value) bool {
func rewriteValuegeneric_OpCom64_0(v *Value) bool {
// match: (Com64 (Com64 x))
// cond:
// result: x
......@@ -5383,7 +5447,7 @@ func rewriteValuegeneric_OpCom64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCom8(v *Value) bool {
func rewriteValuegeneric_OpCom8_0(v *Value) bool {
// match: (Com8 (Com8 x))
// cond:
// result: x
......@@ -5400,7 +5464,7 @@ func rewriteValuegeneric_OpCom8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpConstInterface(v *Value) bool {
func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -5417,7 +5481,7 @@ func rewriteValuegeneric_OpConstInterface(v *Value) bool {
return true
}
}
func rewriteValuegeneric_OpConstSlice(v *Value) bool {
func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -5462,7 +5526,7 @@ func rewriteValuegeneric_OpConstSlice(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpConstString(v *Value) bool {
func rewriteValuegeneric_OpConstString_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -5543,7 +5607,7 @@ func rewriteValuegeneric_OpConstString(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpConvert(v *Value) bool {
func rewriteValuegeneric_OpConvert_0(v *Value) bool {
// match: (Convert (Add64 (Convert ptr mem) off) mem)
// cond:
// result: (Add64 ptr off)
......@@ -5610,7 +5674,7 @@ func rewriteValuegeneric_OpConvert(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F (Const32F [c]))
// cond:
// result: (Const64F [c])
......@@ -5626,7 +5690,7 @@ func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F (Const64F [c]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c)))])
......@@ -5642,7 +5706,7 @@ func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv16(v *Value) bool {
func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -5791,7 +5855,7 @@ func rewriteValuegeneric_OpDiv16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv16u(v *Value) bool {
func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -5972,7 +6036,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv32(v *Value) bool {
func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -6196,7 +6260,7 @@ func rewriteValuegeneric_OpDiv32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv32F(v *Value) bool {
func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Div32F (Const32F [c]) (Const32F [d]))
......@@ -6240,7 +6304,7 @@ func rewriteValuegeneric_OpDiv32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv32u(v *Value) bool {
func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -6478,7 +6542,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv64(v *Value) bool {
func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6661,7 +6725,7 @@ func rewriteValuegeneric_OpDiv64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv64F(v *Value) bool {
func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Div64F (Const64F [c]) (Const64F [d]))
......@@ -6705,7 +6769,7 @@ func rewriteValuegeneric_OpDiv64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv64u(v *Value) bool {
func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -6841,7 +6905,7 @@ func rewriteValuegeneric_OpDiv64u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv8(v *Value) bool {
func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -6990,7 +7054,7 @@ func rewriteValuegeneric_OpDiv8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpDiv8u(v *Value) bool {
func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7067,7 +7131,7 @@ func rewriteValuegeneric_OpDiv8u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEq16(v *Value) bool {
func rewriteValuegeneric_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x x)
......@@ -7240,7 +7304,7 @@ func rewriteValuegeneric_OpEq16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEq32(v *Value) bool {
func rewriteValuegeneric_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x x)
......@@ -7413,7 +7477,7 @@ func rewriteValuegeneric_OpEq32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEq64(v *Value) bool {
func rewriteValuegeneric_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x x)
......@@ -7586,7 +7650,7 @@ func rewriteValuegeneric_OpEq64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEq8(v *Value) bool {
func rewriteValuegeneric_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x x)
......@@ -7759,7 +7823,7 @@ func rewriteValuegeneric_OpEq8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEqB(v *Value) bool {
func rewriteValuegeneric_OpEqB_0(v *Value) bool {
// match: (EqB (ConstBool [c]) (ConstBool [d]))
// cond:
// result: (ConstBool [b2i(c == d)])
......@@ -7813,7 +7877,7 @@ func rewriteValuegeneric_OpEqB(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEqInter(v *Value) bool {
func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7834,7 +7898,7 @@ func rewriteValuegeneric_OpEqInter(v *Value) bool {
return true
}
}
func rewriteValuegeneric_OpEqPtr(v *Value) bool {
func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7927,7 +7991,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpEqSlice(v *Value) bool {
func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -7948,7 +8012,7 @@ func rewriteValuegeneric_OpEqSlice(v *Value) bool {
return true
}
}
func rewriteValuegeneric_OpGeq16(v *Value) bool {
func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
// match: (Geq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
......@@ -7969,7 +8033,7 @@ func rewriteValuegeneric_OpGeq16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq16U(v *Value) bool {
func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
// match: (Geq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
......@@ -7990,7 +8054,7 @@ func rewriteValuegeneric_OpGeq16U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq32(v *Value) bool {
func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
// match: (Geq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
......@@ -8011,7 +8075,7 @@ func rewriteValuegeneric_OpGeq32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq32U(v *Value) bool {
func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
// match: (Geq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
......@@ -8032,7 +8096,7 @@ func rewriteValuegeneric_OpGeq32U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq64(v *Value) bool {
func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
// match: (Geq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
......@@ -8053,7 +8117,7 @@ func rewriteValuegeneric_OpGeq64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq64U(v *Value) bool {
func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
// match: (Geq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
......@@ -8074,7 +8138,7 @@ func rewriteValuegeneric_OpGeq64U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq8(v *Value) bool {
func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
// match: (Geq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
......@@ -8095,7 +8159,7 @@ func rewriteValuegeneric_OpGeq8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGeq8U(v *Value) bool {
func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
// match: (Geq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) >= uint8(d))])
......@@ -8116,7 +8180,7 @@ func rewriteValuegeneric_OpGeq8U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater16(v *Value) bool {
func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
// match: (Greater16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
......@@ -8137,7 +8201,7 @@ func rewriteValuegeneric_OpGreater16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater16U(v *Value) bool {
func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
// match: (Greater16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) > uint16(d))])
......@@ -8158,7 +8222,7 @@ func rewriteValuegeneric_OpGreater16U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater32(v *Value) bool {
func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
// match: (Greater32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
......@@ -8179,7 +8243,7 @@ func rewriteValuegeneric_OpGreater32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater32U(v *Value) bool {
func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
// match: (Greater32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) > uint32(d))])
......@@ -8200,7 +8264,7 @@ func rewriteValuegeneric_OpGreater32U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater64(v *Value) bool {
func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
// match: (Greater64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
......@@ -8221,7 +8285,7 @@ func rewriteValuegeneric_OpGreater64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater64U(v *Value) bool {
func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
// match: (Greater64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) > uint64(d))])
......@@ -8242,7 +8306,7 @@ func rewriteValuegeneric_OpGreater64U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater8(v *Value) bool {
func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
// match: (Greater8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
......@@ -8263,7 +8327,7 @@ func rewriteValuegeneric_OpGreater8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpGreater8U(v *Value) bool {
func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
// match: (Greater8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) > uint8(d))])
......@@ -8284,7 +8348,7 @@ func rewriteValuegeneric_OpGreater8U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpIMake(v *Value) bool {
func rewriteValuegeneric_OpIMake_0(v *Value) bool {
// match: (IMake typ (StructMake1 val))
// cond:
// result: (IMake typ val)
......@@ -8317,7 +8381,7 @@ func rewriteValuegeneric_OpIMake(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpInterCall(v *Value) bool {
func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
// cond: devirt(v, itab, off) != nil
// result: (StaticCall [argsize] {devirt(v, itab, off)} mem)
......@@ -8361,7 +8425,7 @@ func rewriteValuegeneric_OpInterCall(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
// cond: (1 << 8) <= c
// result: (ConstBool [1])
......@@ -8591,6 +8655,9 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
v.AuxInt = 1
return true
}
return false
}
func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
// match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d]))
// cond: 0 <= c && c < d
// result: (ConstBool [1])
......@@ -8869,6 +8936,9 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
v.AuxInt = 1
return true
}
return false
}
func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
// match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d]))
// cond: 0 <= c && c < d
// result: (ConstBool [1])
......@@ -9072,7 +9142,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpIsNonNil(v *Value) bool {
func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
// match: (IsNonNil (ConstNil))
// cond:
// result: (ConstBool [0])
......@@ -9087,7 +9157,7 @@ func rewriteValuegeneric_OpIsNonNil(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
// match: (IsSliceInBounds x x)
// cond:
// result: (ConstBool [1])
......@@ -9288,7 +9358,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq16(v *Value) bool {
func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
// match: (Leq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
......@@ -9309,7 +9379,7 @@ func rewriteValuegeneric_OpLeq16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq16U(v *Value) bool {
func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
// match: (Leq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
......@@ -9330,7 +9400,7 @@ func rewriteValuegeneric_OpLeq16U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq32(v *Value) bool {
func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
// match: (Leq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
......@@ -9351,7 +9421,7 @@ func rewriteValuegeneric_OpLeq32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq32U(v *Value) bool {
func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
// match: (Leq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
......@@ -9372,7 +9442,7 @@ func rewriteValuegeneric_OpLeq32U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq64(v *Value) bool {
func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
// match: (Leq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
......@@ -9393,7 +9463,7 @@ func rewriteValuegeneric_OpLeq64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq64U(v *Value) bool {
func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
// match: (Leq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
......@@ -9414,7 +9484,7 @@ func rewriteValuegeneric_OpLeq64U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq8(v *Value) bool {
func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
// match: (Leq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
......@@ -9435,7 +9505,7 @@ func rewriteValuegeneric_OpLeq8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLeq8U(v *Value) bool {
func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
// match: (Leq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) <= uint8(d))])
......@@ -9456,7 +9526,7 @@ func rewriteValuegeneric_OpLeq8U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess16(v *Value) bool {
func rewriteValuegeneric_OpLess16_0(v *Value) bool {
// match: (Less16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
......@@ -9477,7 +9547,7 @@ func rewriteValuegeneric_OpLess16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess16U(v *Value) bool {
func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
// match: (Less16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) < uint16(d))])
......@@ -9498,7 +9568,7 @@ func rewriteValuegeneric_OpLess16U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess32(v *Value) bool {
func rewriteValuegeneric_OpLess32_0(v *Value) bool {
// match: (Less32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
......@@ -9519,7 +9589,7 @@ func rewriteValuegeneric_OpLess32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess32U(v *Value) bool {
func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
// match: (Less32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) < uint32(d))])
......@@ -9540,7 +9610,7 @@ func rewriteValuegeneric_OpLess32U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess64(v *Value) bool {
func rewriteValuegeneric_OpLess64_0(v *Value) bool {
// match: (Less64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
......@@ -9561,7 +9631,7 @@ func rewriteValuegeneric_OpLess64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess64U(v *Value) bool {
func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
// match: (Less64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) < uint64(d))])
......@@ -9582,7 +9652,7 @@ func rewriteValuegeneric_OpLess64U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess8(v *Value) bool {
func rewriteValuegeneric_OpLess8_0(v *Value) bool {
// match: (Less8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
......@@ -9603,7 +9673,7 @@ func rewriteValuegeneric_OpLess8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLess8U(v *Value) bool {
func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
// match: (Less8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) < uint8(d))])
......@@ -9624,7 +9694,7 @@ func rewriteValuegeneric_OpLess8U(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLoad(v *Value) bool {
func rewriteValuegeneric_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
fe := b.Func.fe
......@@ -9813,7 +9883,7 @@ func rewriteValuegeneric_OpLoad(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh16x16(v *Value) bool {
func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x (Const16 [c]))
......@@ -9851,7 +9921,7 @@ func rewriteValuegeneric_OpLsh16x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh16x32(v *Value) bool {
func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x (Const32 [c]))
......@@ -9889,7 +9959,7 @@ func rewriteValuegeneric_OpLsh16x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -10030,7 +10100,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh16x8(v *Value) bool {
func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x (Const8 [c]))
......@@ -10068,7 +10138,7 @@ func rewriteValuegeneric_OpLsh16x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh32x16(v *Value) bool {
func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x (Const16 [c]))
......@@ -10106,7 +10176,7 @@ func rewriteValuegeneric_OpLsh32x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh32x32(v *Value) bool {
func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x (Const32 [c]))
......@@ -10144,7 +10214,7 @@ func rewriteValuegeneric_OpLsh32x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -10285,7 +10355,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh32x8(v *Value) bool {
func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x (Const8 [c]))
......@@ -10323,7 +10393,7 @@ func rewriteValuegeneric_OpLsh32x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh64x16(v *Value) bool {
func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x16 <t> x (Const16 [c]))
......@@ -10361,7 +10431,7 @@ func rewriteValuegeneric_OpLsh64x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh64x32(v *Value) bool {
func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x (Const32 [c]))
......@@ -10399,7 +10469,7 @@ func rewriteValuegeneric_OpLsh64x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -10540,7 +10610,7 @@ func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh64x8(v *Value) bool {
func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x8 <t> x (Const8 [c]))
......@@ -10578,7 +10648,7 @@ func rewriteValuegeneric_OpLsh64x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh8x16(v *Value) bool {
func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x (Const16 [c]))
......@@ -10616,7 +10686,7 @@ func rewriteValuegeneric_OpLsh8x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh8x32(v *Value) bool {
func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x (Const32 [c]))
......@@ -10654,7 +10724,7 @@ func rewriteValuegeneric_OpLsh8x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -10795,7 +10865,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpLsh8x8(v *Value) bool {
func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x (Const8 [c]))
......@@ -10833,7 +10903,7 @@ func rewriteValuegeneric_OpLsh8x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod16(v *Value) bool {
func rewriteValuegeneric_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod16 (Const16 [c]) (Const16 [d]))
......@@ -10910,7 +10980,7 @@ func rewriteValuegeneric_OpMod16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod16u(v *Value) bool {
func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod16u (Const16 [c]) (Const16 [d]))
......@@ -10986,7 +11056,7 @@ func rewriteValuegeneric_OpMod16u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod32(v *Value) bool {
func rewriteValuegeneric_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod32 (Const32 [c]) (Const32 [d]))
......@@ -11063,7 +11133,7 @@ func rewriteValuegeneric_OpMod32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod32u(v *Value) bool {
func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod32u (Const32 [c]) (Const32 [d]))
......@@ -11139,7 +11209,7 @@ func rewriteValuegeneric_OpMod32u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod64(v *Value) bool {
func rewriteValuegeneric_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod64 (Const64 [c]) (Const64 [d]))
......@@ -11216,7 +11286,7 @@ func rewriteValuegeneric_OpMod64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod64u(v *Value) bool {
func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod64u (Const64 [c]) (Const64 [d]))
......@@ -11292,7 +11362,7 @@ func rewriteValuegeneric_OpMod64u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod8(v *Value) bool {
func rewriteValuegeneric_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod8 (Const8 [c]) (Const8 [d]))
......@@ -11369,7 +11439,7 @@ func rewriteValuegeneric_OpMod8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMod8u(v *Value) bool {
func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod8u (Const8 [c]) (Const8 [d]))
......@@ -11445,7 +11515,7 @@ func rewriteValuegeneric_OpMod8u(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul16(v *Value) bool {
func rewriteValuegeneric_OpMul16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -11642,6 +11712,11 @@ func rewriteValuegeneric_OpMul16(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpMul16_10(v *Value) bool {
b := v.Block
_ = b
// match: (Mul16 (Const16 [0]) _)
// cond:
// result: (Const16 [0])
......@@ -11794,7 +11869,7 @@ func rewriteValuegeneric_OpMul16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul32(v *Value) bool {
func rewriteValuegeneric_OpMul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -11991,6 +12066,11 @@ func rewriteValuegeneric_OpMul32(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpMul32_10(v *Value) bool {
b := v.Block
_ = b
// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
......@@ -12295,7 +12375,7 @@ func rewriteValuegeneric_OpMul32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul32F(v *Value) bool {
func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
// match: (Mul32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))])
......@@ -12434,7 +12514,7 @@ func rewriteValuegeneric_OpMul32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul64(v *Value) bool {
func rewriteValuegeneric_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -12631,6 +12711,11 @@ func rewriteValuegeneric_OpMul64(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpMul64_10(v *Value) bool {
b := v.Block
_ = b
// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
// cond:
// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
......@@ -12935,7 +13020,7 @@ func rewriteValuegeneric_OpMul64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul64F(v *Value) bool {
func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
// match: (Mul64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) * i2f(d))])
......@@ -13074,7 +13159,7 @@ func rewriteValuegeneric_OpMul64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpMul8(v *Value) bool {
func rewriteValuegeneric_OpMul8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -13271,6 +13356,11 @@ func rewriteValuegeneric_OpMul8(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpMul8_10(v *Value) bool {
b := v.Block
_ = b
// match: (Mul8 (Const8 [0]) _)
// cond:
// result: (Const8 [0])
......@@ -13423,7 +13513,7 @@ func rewriteValuegeneric_OpMul8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg16(v *Value) bool {
func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
// match: (Neg16 (Const16 [c]))
// cond:
// result: (Const16 [int64(-int16(c))])
......@@ -13454,7 +13544,7 @@ func rewriteValuegeneric_OpNeg16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg32(v *Value) bool {
func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
// match: (Neg32 (Const32 [c]))
// cond:
// result: (Const32 [int64(-int32(c))])
......@@ -13485,7 +13575,7 @@ func rewriteValuegeneric_OpNeg32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg32F(v *Value) bool {
func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
// match: (Neg32F (Const32F [c]))
// cond: i2f(c) != 0
// result: (Const32F [f2i(-i2f(c))])
......@@ -13504,7 +13594,7 @@ func rewriteValuegeneric_OpNeg32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg64(v *Value) bool {
func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
// match: (Neg64 (Const64 [c]))
// cond:
// result: (Const64 [-c])
......@@ -13535,7 +13625,7 @@ func rewriteValuegeneric_OpNeg64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg64F(v *Value) bool {
func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
// match: (Neg64F (Const64F [c]))
// cond: i2f(c) != 0
// result: (Const64F [f2i(-i2f(c))])
......@@ -13554,7 +13644,7 @@ func rewriteValuegeneric_OpNeg64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeg8(v *Value) bool {
func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
// match: (Neg8 (Const8 [c]))
// cond:
// result: (Const8 [int64( -int8(c))])
......@@ -13585,7 +13675,7 @@ func rewriteValuegeneric_OpNeg8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeq16(v *Value) bool {
func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x x)
......@@ -13758,7 +13848,7 @@ func rewriteValuegeneric_OpNeq16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeq32(v *Value) bool {
func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x x)
......@@ -13931,7 +14021,7 @@ func rewriteValuegeneric_OpNeq32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeq64(v *Value) bool {
func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x x)
......@@ -14104,7 +14194,7 @@ func rewriteValuegeneric_OpNeq64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeq8(v *Value) bool {
func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x x)
......@@ -14277,7 +14367,7 @@ func rewriteValuegeneric_OpNeq8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeqB(v *Value) bool {
func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
// match: (NeqB (ConstBool [c]) (ConstBool [d]))
// cond:
// result: (ConstBool [b2i(c != d)])
......@@ -14331,7 +14421,7 @@ func rewriteValuegeneric_OpNeqB(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeqInter(v *Value) bool {
func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -14352,7 +14442,7 @@ func rewriteValuegeneric_OpNeqInter(v *Value) bool {
return true
}
}
func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
// match: (NeqPtr p (ConstNil))
// cond:
// result: (IsNonNil p)
......@@ -14381,7 +14471,7 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -14402,7 +14492,7 @@ func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
return true
}
}
func rewriteValuegeneric_OpNilCheck(v *Value) bool {
func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -14486,7 +14576,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpNot(v *Value) bool {
func rewriteValuegeneric_OpNot_0(v *Value) bool {
// match: (Not (Eq64 x y))
// cond:
// result: (Neq64 x y)
......@@ -14637,6 +14727,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpNot_10(v *Value) bool {
// match: (Not (Greater64 x y))
// cond:
// result: (Leq64 x y)
......@@ -14787,6 +14880,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpNot_20(v *Value) bool {
// match: (Not (Geq16 x y))
// cond:
// result: (Less16 x y)
......@@ -14937,6 +15033,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpNot_30(v *Value) bool {
// match: (Not (Less64U x y))
// cond:
// result: (Geq64U x y)
......@@ -15087,6 +15186,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpNot_40(v *Value) bool {
// match: (Not (Leq16U x y))
// cond:
// result: (Greater16U x y)
......@@ -15119,7 +15221,7 @@ func rewriteValuegeneric_OpNot(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpOffPtr(v *Value) bool {
func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
// match: (OffPtr (OffPtr p [b]) [a])
// cond:
// result: (OffPtr p [a+b])
......@@ -15154,9 +15256,7 @@ func rewriteValuegeneric_OpOffPtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpOr16(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpOr16_0(v *Value) bool {
// match: (Or16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [int64(int16(c|d))])
......@@ -15324,6 +15424,11 @@ func rewriteValuegeneric_OpOr16(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpOr16_10(v *Value) bool {
b := v.Block
_ = b
// match: (Or16 (Or16 y x) x)
// cond:
// result: (Or16 x y)
......@@ -15568,9 +15673,7 @@ func rewriteValuegeneric_OpOr16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpOr32(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpOr32_0(v *Value) bool {
// match: (Or32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [int64(int32(c|d))])
......@@ -15738,6 +15841,11 @@ func rewriteValuegeneric_OpOr32(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpOr32_10(v *Value) bool {
b := v.Block
_ = b
// match: (Or32 (Or32 y x) x)
// cond:
// result: (Or32 x y)
......@@ -15982,9 +16090,7 @@ func rewriteValuegeneric_OpOr32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpOr64(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpOr64_0(v *Value) bool {
// match: (Or64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c|d])
......@@ -16152,6 +16258,11 @@ func rewriteValuegeneric_OpOr64(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpOr64_10(v *Value) bool {
b := v.Block
_ = b
// match: (Or64 (Or64 y x) x)
// cond:
// result: (Or64 x y)
......@@ -16396,9 +16507,7 @@ func rewriteValuegeneric_OpOr64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpOr8(v *Value) bool {
b := v.Block
_ = b
func rewriteValuegeneric_OpOr8_0(v *Value) bool {
// match: (Or8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [int64(int8(c|d))])
......@@ -16566,6 +16675,11 @@ func rewriteValuegeneric_OpOr8(v *Value) bool {
v.AddArg(y)
return true
}
return false
}
func rewriteValuegeneric_OpOr8_10(v *Value) bool {
b := v.Block
_ = b
// match: (Or8 (Or8 y x) x)
// cond:
// result: (Or8 x y)
......@@ -16810,7 +16924,7 @@ func rewriteValuegeneric_OpOr8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpPhi(v *Value) bool {
func rewriteValuegeneric_OpPhi_0(v *Value) bool {
// match: (Phi (Const8 [c]) (Const8 [c]))
// cond:
// result: (Const8 [c])
......@@ -16905,7 +17019,7 @@ func rewriteValuegeneric_OpPhi(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpPtrIndex(v *Value) bool {
func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -16954,7 +17068,7 @@ func rewriteValuegeneric_OpPtrIndex(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRound32F(v *Value) bool {
func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
// match: (Round32F x:(Const32F))
// cond:
// result: x
......@@ -16970,7 +17084,7 @@ func rewriteValuegeneric_OpRound32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRound64F(v *Value) bool {
func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
// match: (Round64F x:(Const64F))
// cond:
// result: x
......@@ -16986,7 +17100,7 @@ func rewriteValuegeneric_OpRound64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool {
func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x (Const16 [c]))
......@@ -17024,7 +17138,7 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool {
func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x (Const32 [c]))
......@@ -17062,7 +17176,7 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -17232,7 +17346,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool {
func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x (Const8 [c]))
......@@ -17270,7 +17384,7 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16x16(v *Value) bool {
func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x (Const16 [c]))
......@@ -17308,7 +17422,7 @@ func rewriteValuegeneric_OpRsh16x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16x32(v *Value) bool {
func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x (Const32 [c]))
......@@ -17346,7 +17460,7 @@ func rewriteValuegeneric_OpRsh16x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -17462,7 +17576,7 @@ func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh16x8(v *Value) bool {
func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x (Const8 [c]))
......@@ -17500,7 +17614,7 @@ func rewriteValuegeneric_OpRsh16x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool {
func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x (Const16 [c]))
......@@ -17538,7 +17652,7 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool {
func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x (Const32 [c]))
......@@ -17576,7 +17690,7 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -17775,7 +17889,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool {
func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x (Const8 [c]))
......@@ -17813,7 +17927,7 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32x16(v *Value) bool {
func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x (Const16 [c]))
......@@ -17851,7 +17965,7 @@ func rewriteValuegeneric_OpRsh32x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32x32(v *Value) bool {
func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x (Const32 [c]))
......@@ -17889,7 +18003,7 @@ func rewriteValuegeneric_OpRsh32x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -18034,7 +18148,7 @@ func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh32x8(v *Value) bool {
func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x (Const8 [c]))
......@@ -18072,7 +18186,7 @@ func rewriteValuegeneric_OpRsh32x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool {
func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux16 <t> x (Const16 [c]))
......@@ -18110,7 +18224,7 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool {
func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x (Const32 [c]))
......@@ -18148,7 +18262,7 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -18376,7 +18490,7 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool {
func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux8 <t> x (Const8 [c]))
......@@ -18414,7 +18528,7 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64x16(v *Value) bool {
func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x16 <t> x (Const16 [c]))
......@@ -18452,7 +18566,7 @@ func rewriteValuegeneric_OpRsh64x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64x32(v *Value) bool {
func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x (Const32 [c]))
......@@ -18490,7 +18604,7 @@ func rewriteValuegeneric_OpRsh64x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -18664,7 +18778,7 @@ func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh64x8(v *Value) bool {
func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x8 <t> x (Const8 [c]))
......@@ -18702,7 +18816,7 @@ func rewriteValuegeneric_OpRsh64x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool {
func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x (Const16 [c]))
......@@ -18740,7 +18854,7 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool {
func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x (Const32 [c]))
......@@ -18778,7 +18892,7 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
......@@ -18919,7 +19033,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool {
func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x (Const8 [c]))
......@@ -18957,7 +19071,7 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8x16(v *Value) bool {
func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x (Const16 [c]))
......@@ -18995,7 +19109,7 @@ func rewriteValuegeneric_OpRsh8x16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8x32(v *Value) bool {
func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x (Const32 [c]))
......@@ -19033,7 +19147,7 @@ func rewriteValuegeneric_OpRsh8x32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
......@@ -19118,7 +19232,7 @@ func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpRsh8x8(v *Value) bool {
func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x (Const8 [c]))
......@@ -19156,7 +19270,7 @@ func rewriteValuegeneric_OpRsh8x8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 (Const16 [c]))
// cond:
// result: (Const32 [int64( int16(c))])
......@@ -19197,7 +19311,7 @@ func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 (Const16 [c]))
// cond:
// result: (Const64 [int64( int16(c))])
......@@ -19238,7 +19352,7 @@ func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 (Const32 [c]))
// cond:
// result: (Const64 [int64( int32(c))])
......@@ -19279,7 +19393,7 @@ func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 (Const8 [c]))
// cond:
// result: (Const16 [int64( int8(c))])
......@@ -19320,7 +19434,7 @@ func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 (Const8 [c]))
// cond:
// result: (Const32 [int64( int8(c))])
......@@ -19361,7 +19475,7 @@ func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 (Const8 [c]))
// cond:
// result: (Const64 [int64( int8(c))])
......@@ -19402,7 +19516,7 @@ func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSliceCap(v *Value) bool {
func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
// cond:
// result: (Const64 <t> [c])
......@@ -19477,7 +19591,7 @@ func rewriteValuegeneric_OpSliceCap(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSliceLen(v *Value) bool {
func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
// cond:
// result: (Const64 <t> [c])
......@@ -19535,7 +19649,7 @@ func rewriteValuegeneric_OpSliceLen(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSlicePtr(v *Value) bool {
func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
// cond:
// result: (SlicePtr x)
......@@ -19555,7 +19669,7 @@ func rewriteValuegeneric_OpSlicePtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSlicemask(v *Value) bool {
func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
// match: (Slicemask (Const32 [x]))
// cond: x > 0
// result: (Const32 [-1])
......@@ -19620,7 +19734,7 @@ func rewriteValuegeneric_OpSlicemask(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSqrt(v *Value) bool {
func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
// match: (Sqrt (Const64F [c]))
// cond:
// result: (Const64F [f2i(math.Sqrt(i2f(c)))])
......@@ -19636,7 +19750,7 @@ func rewriteValuegeneric_OpSqrt(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpStore(v *Value) bool {
func rewriteValuegeneric_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -19921,6 +20035,13 @@ func rewriteValuegeneric_OpStore(v *Value) bool {
v.AddArg(mem)
return true
}
return false
}
func rewriteValuegeneric_OpStore_10(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
_ = config
// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
// result: mem
......@@ -19957,7 +20078,7 @@ func rewriteValuegeneric_OpStore(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpStringLen(v *Value) bool {
func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
// match: (StringLen (StringMake _ (Const64 <t> [c])))
// cond:
// result: (Const64 <t> [c])
......@@ -19979,7 +20100,7 @@ func rewriteValuegeneric_OpStringLen(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpStringPtr(v *Value) bool {
func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
// match: (StringPtr (StringMake (Const64 <t> [c]) _))
// cond:
// result: (Const64 <t> [c])
......@@ -20001,11 +20122,7 @@ func rewriteValuegeneric_OpStringPtr(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpStructSelect(v *Value) bool {
b := v.Block
_ = b
fe := b.Func.fe
_ = fe
func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
// match: (StructSelect (StructMake1 x))
// cond:
// result: x
......@@ -20173,6 +20290,13 @@ func rewriteValuegeneric_OpStructSelect(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
b := v.Block
_ = b
fe := b.Func.fe
_ = fe
// match: (StructSelect [i] x:(Load <t> ptr mem))
// cond: !fe.CanSSA(t)
// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
......@@ -20217,7 +20341,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub16(v *Value) bool {
func rewriteValuegeneric_OpSub16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub16 (Const16 [c]) (Const16 [d]))
......@@ -20425,6 +20549,11 @@ func rewriteValuegeneric_OpSub16(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpSub16_10(v *Value) bool {
b := v.Block
_ = b
// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
// cond:
// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
......@@ -20457,7 +20586,7 @@ func rewriteValuegeneric_OpSub16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub32(v *Value) bool {
func rewriteValuegeneric_OpSub32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub32 (Const32 [c]) (Const32 [d]))
......@@ -20665,6 +20794,11 @@ func rewriteValuegeneric_OpSub32(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpSub32_10(v *Value) bool {
b := v.Block
_ = b
// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
......@@ -20697,7 +20831,7 @@ func rewriteValuegeneric_OpSub32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub32F(v *Value) bool {
func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
// match: (Sub32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))])
......@@ -20735,7 +20869,7 @@ func rewriteValuegeneric_OpSub32F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub64(v *Value) bool {
func rewriteValuegeneric_OpSub64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub64 (Const64 [c]) (Const64 [d]))
......@@ -20943,6 +21077,11 @@ func rewriteValuegeneric_OpSub64(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpSub64_10(v *Value) bool {
b := v.Block
_ = b
// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
// cond:
// result: (Add64 (Const64 <t> [c-d]) x)
......@@ -20975,7 +21114,7 @@ func rewriteValuegeneric_OpSub64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub64F(v *Value) bool {
func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
// match: (Sub64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) - i2f(d))])
......@@ -21013,7 +21152,7 @@ func rewriteValuegeneric_OpSub64F(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpSub8(v *Value) bool {
func rewriteValuegeneric_OpSub8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub8 (Const8 [c]) (Const8 [d]))
......@@ -21221,6 +21360,11 @@ func rewriteValuegeneric_OpSub8(v *Value) bool {
v.AddArg(x)
return true
}
return false
}
func rewriteValuegeneric_OpSub8_10(v *Value) bool {
b := v.Block
_ = b
// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
// cond:
// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
......@@ -21253,7 +21397,7 @@ func rewriteValuegeneric_OpSub8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 (Const16 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
......@@ -21339,7 +21483,7 @@ func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 (Const32 [c]))
// cond:
// result: (Const16 [int64(int16(c))])
......@@ -21451,7 +21595,7 @@ func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 (Const32 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
......@@ -21537,7 +21681,7 @@ func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 (Const64 [c]))
// cond:
// result: (Const16 [int64(int16(c))])
......@@ -21649,7 +21793,7 @@ func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 (Const64 [c]))
// cond:
// result: (Const32 [int64(int32(c))])
......@@ -21787,7 +21931,7 @@ func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 (Const64 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
......@@ -21873,7 +22017,7 @@ func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpXor16(v *Value) bool {
func rewriteValuegeneric_OpXor16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor16 (Const16 [c]) (Const16 [d]))
......@@ -22056,6 +22200,11 @@ func rewriteValuegeneric_OpXor16(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpXor16_10(v *Value) bool {
b := v.Block
_ = b
// match: (Xor16 (Xor16 z i:(Const16 <t>)) x)
// cond: (z.Op != OpConst16 && x.Op != OpConst16)
// result: (Xor16 i (Xor16 <t> z x))
......@@ -22256,7 +22405,7 @@ func rewriteValuegeneric_OpXor16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpXor32(v *Value) bool {
func rewriteValuegeneric_OpXor32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor32 (Const32 [c]) (Const32 [d]))
......@@ -22439,6 +22588,11 @@ func rewriteValuegeneric_OpXor32(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpXor32_10(v *Value) bool {
b := v.Block
_ = b
// match: (Xor32 (Xor32 z i:(Const32 <t>)) x)
// cond: (z.Op != OpConst32 && x.Op != OpConst32)
// result: (Xor32 i (Xor32 <t> z x))
......@@ -22639,7 +22793,7 @@ func rewriteValuegeneric_OpXor32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpXor64(v *Value) bool {
func rewriteValuegeneric_OpXor64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor64 (Const64 [c]) (Const64 [d]))
......@@ -22822,6 +22976,11 @@ func rewriteValuegeneric_OpXor64(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpXor64_10(v *Value) bool {
b := v.Block
_ = b
// match: (Xor64 (Xor64 z i:(Const64 <t>)) x)
// cond: (z.Op != OpConst64 && x.Op != OpConst64)
// result: (Xor64 i (Xor64 <t> z x))
......@@ -23022,7 +23181,7 @@ func rewriteValuegeneric_OpXor64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpXor8(v *Value) bool {
func rewriteValuegeneric_OpXor8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor8 (Const8 [c]) (Const8 [d]))
......@@ -23205,6 +23364,11 @@ func rewriteValuegeneric_OpXor8(v *Value) bool {
v.AddArg(v0)
return true
}
return false
}
func rewriteValuegeneric_OpXor8_10(v *Value) bool {
b := v.Block
_ = b
// match: (Xor8 (Xor8 z i:(Const8 <t>)) x)
// cond: (z.Op != OpConst8 && x.Op != OpConst8)
// result: (Xor8 i (Xor8 <t> z x))
......@@ -23405,7 +23569,7 @@ func rewriteValuegeneric_OpXor8(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZero(v *Value) bool {
func rewriteValuegeneric_OpZero_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
......@@ -23441,7 +23605,7 @@ func rewriteValuegeneric_OpZero(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 (Const16 [c]))
// cond:
// result: (Const32 [int64(uint16(c))])
......@@ -23482,7 +23646,7 @@ func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 (Const16 [c]))
// cond:
// result: (Const64 [int64(uint16(c))])
......@@ -23523,7 +23687,7 @@ func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 (Const32 [c]))
// cond:
// result: (Const64 [int64(uint32(c))])
......@@ -23564,7 +23728,7 @@ func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 (Const8 [c]))
// cond:
// result: (Const16 [int64( uint8(c))])
......@@ -23605,7 +23769,7 @@ func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 (Const8 [c]))
// cond:
// result: (Const32 [int64( uint8(c))])
......@@ -23646,7 +23810,7 @@ func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
}
return false
}
func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool {
func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 (Const8 [c]))
// cond:
// result: (Const64 [int64( uint8(c))])
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7