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/41296
Reviewed-by: Keith Randall <khr@golang.org>
diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go
index 94898e3..2a07d5b 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -162,12 +162,20 @@
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,67 +184,73 @@
// 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 {
- buf := new(bytes.Buffer)
- var canFail bool
- for i, rule := range oprules[op] {
- match, cond, result := rule.parse()
- fmt.Fprintf(buf, "// match: %s\n", match)
- fmt.Fprintf(buf, "// cond: %s\n", cond)
- fmt.Fprintf(buf, "// result: %s\n", result)
+ for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
+ buf := new(bytes.Buffer)
+ var canFail bool
+ 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)
+ fmt.Fprintf(buf, "// result: %s\n", result)
- canFail = false
- fmt.Fprintf(buf, "for {\n")
- if genMatch(buf, arch, match, rule.loc) {
- canFail = true
+ canFail = false
+ fmt.Fprintf(buf, "for {\n")
+ if genMatch(buf, arch, match, rule.loc) {
+ canFail = true
+ }
+
+ if cond != "" {
+ fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
+ canFail = true
+ }
+ if !canFail && i+chunk != len(oprules[op])-1 {
+ log.Fatalf("unconditional rule %s is followed by other rules", match)
+ }
+
+ genResult(buf, arch, result, rule.loc)
+ if *genLog {
+ fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+ }
+ fmt.Fprintf(buf, "return true\n")
+
+ fmt.Fprintf(buf, "}\n")
+ }
+ if canFail {
+ fmt.Fprintf(buf, "return false\n")
}
- if cond != "" {
- fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
- canFail = true
+ body := buf.String()
+ // Do a rough match to predict whether we need b, config, fe, and/or types.
+ // It's not precise--thus the blank assignments--but it's good enough
+ // to avoid generating needless code and doing pointless nil checks.
+ hasb := strings.Contains(body, "b.")
+ 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_%d(v *Value) bool {\n", arch.name, op, chunk)
+ if hasb || hasconfig || hasfe {
+ fmt.Fprintln(w, "b := v.Block")
+ fmt.Fprintln(w, "_ = b")
}
- if !canFail && i != len(oprules[op])-1 {
- log.Fatalf("unconditional rule %s is followed by other rules", match)
+ if hasconfig {
+ fmt.Fprintln(w, "config := b.Func.Config")
+ fmt.Fprintln(w, "_ = config")
}
-
- genResult(buf, arch, result, rule.loc)
- if *genLog {
- fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+ if hasfe {
+ fmt.Fprintln(w, "fe := b.Func.fe")
+ fmt.Fprintln(w, "_ = fe")
}
- fmt.Fprintf(buf, "return true\n")
-
- fmt.Fprintf(buf, "}\n")
+ if hasts {
+ fmt.Fprintln(w, "types := &b.Func.Config.Types")
+ fmt.Fprintln(w, "_ = types")
+ }
+ fmt.Fprint(w, body)
+ fmt.Fprintf(w, "}\n")
}
- if canFail {
- fmt.Fprintf(buf, "return false\n")
- }
-
- body := buf.String()
- // Do a rough match to predict whether we need b, config, fe, and/or types.
- // It's not precise--thus the blank assignments--but it's good enough
- // to avoid generating needless code and doing pointless nil checks.
- hasb := strings.Contains(body, "b.")
- 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)
- if hasb || hasconfig || hasfe {
- fmt.Fprintln(w, "b := v.Block")
- fmt.Fprintln(w, "_ = b")
- }
- if hasconfig {
- fmt.Fprintln(w, "config := b.Func.Config")
- fmt.Fprintln(w, "_ = config")
- }
- if hasfe {
- fmt.Fprintln(w, "fe := b.Func.fe")
- fmt.Fprintln(w, "_ = fe")
- }
- if hasts {
- fmt.Fprintln(w, "types := &b.Func.Config.Types")
- fmt.Fprintln(w, "_ = types")
- }
- fmt.Fprint(w, body)
- fmt.Fprintf(w, "}\n")
}
// Generate block rewrite function. There are only a few block types
diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go
index 58ef586..d6509ae 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -14,583 +14,583 @@
func rewriteValue386(v *Value) bool {
switch v.Op {
case Op386ADCL:
- return rewriteValue386_Op386ADCL(v)
+ return rewriteValue386_Op386ADCL_0(v)
case Op386ADDL:
- return rewriteValue386_Op386ADDL(v)
+ return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v)
case Op386ADDLcarry:
- return rewriteValue386_Op386ADDLcarry(v)
+ return rewriteValue386_Op386ADDLcarry_0(v)
case Op386ADDLconst:
- return rewriteValue386_Op386ADDLconst(v)
+ return rewriteValue386_Op386ADDLconst_0(v)
case Op386ANDL:
- return rewriteValue386_Op386ANDL(v)
+ return rewriteValue386_Op386ANDL_0(v)
case Op386ANDLconst:
- return rewriteValue386_Op386ANDLconst(v)
+ return rewriteValue386_Op386ANDLconst_0(v)
case Op386CMPB:
- return rewriteValue386_Op386CMPB(v)
+ return rewriteValue386_Op386CMPB_0(v)
case Op386CMPBconst:
- return rewriteValue386_Op386CMPBconst(v)
+ return rewriteValue386_Op386CMPBconst_0(v)
case Op386CMPL:
- return rewriteValue386_Op386CMPL(v)
+ return rewriteValue386_Op386CMPL_0(v)
case Op386CMPLconst:
- return rewriteValue386_Op386CMPLconst(v)
+ return rewriteValue386_Op386CMPLconst_0(v)
case Op386CMPW:
- return rewriteValue386_Op386CMPW(v)
+ return rewriteValue386_Op386CMPW_0(v)
case Op386CMPWconst:
- return rewriteValue386_Op386CMPWconst(v)
+ return rewriteValue386_Op386CMPWconst_0(v)
case Op386LEAL:
- return rewriteValue386_Op386LEAL(v)
+ return rewriteValue386_Op386LEAL_0(v)
case Op386LEAL1:
- return rewriteValue386_Op386LEAL1(v)
+ return rewriteValue386_Op386LEAL1_0(v)
case Op386LEAL2:
- return rewriteValue386_Op386LEAL2(v)
+ return rewriteValue386_Op386LEAL2_0(v)
case Op386LEAL4:
- return rewriteValue386_Op386LEAL4(v)
+ return rewriteValue386_Op386LEAL4_0(v)
case Op386LEAL8:
- return rewriteValue386_Op386LEAL8(v)
+ return rewriteValue386_Op386LEAL8_0(v)
case Op386MOVBLSX:
- return rewriteValue386_Op386MOVBLSX(v)
+ return rewriteValue386_Op386MOVBLSX_0(v)
case Op386MOVBLSXload:
- return rewriteValue386_Op386MOVBLSXload(v)
+ return rewriteValue386_Op386MOVBLSXload_0(v)
case Op386MOVBLZX:
- return rewriteValue386_Op386MOVBLZX(v)
+ return rewriteValue386_Op386MOVBLZX_0(v)
case Op386MOVBload:
- return rewriteValue386_Op386MOVBload(v)
+ return rewriteValue386_Op386MOVBload_0(v)
case Op386MOVBloadidx1:
- return rewriteValue386_Op386MOVBloadidx1(v)
+ return rewriteValue386_Op386MOVBloadidx1_0(v)
case Op386MOVBstore:
- return rewriteValue386_Op386MOVBstore(v)
+ return rewriteValue386_Op386MOVBstore_0(v)
case Op386MOVBstoreconst:
- return rewriteValue386_Op386MOVBstoreconst(v)
+ return rewriteValue386_Op386MOVBstoreconst_0(v)
case Op386MOVBstoreconstidx1:
- return rewriteValue386_Op386MOVBstoreconstidx1(v)
+ return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
case Op386MOVBstoreidx1:
- return rewriteValue386_Op386MOVBstoreidx1(v)
+ return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v)
case Op386MOVLload:
- return rewriteValue386_Op386MOVLload(v)
+ return rewriteValue386_Op386MOVLload_0(v)
case Op386MOVLloadidx1:
- return rewriteValue386_Op386MOVLloadidx1(v)
+ return rewriteValue386_Op386MOVLloadidx1_0(v)
case Op386MOVLloadidx4:
- return rewriteValue386_Op386MOVLloadidx4(v)
+ return rewriteValue386_Op386MOVLloadidx4_0(v)
case Op386MOVLstore:
- return rewriteValue386_Op386MOVLstore(v)
+ return rewriteValue386_Op386MOVLstore_0(v)
case Op386MOVLstoreconst:
- return rewriteValue386_Op386MOVLstoreconst(v)
+ return rewriteValue386_Op386MOVLstoreconst_0(v)
case Op386MOVLstoreconstidx1:
- return rewriteValue386_Op386MOVLstoreconstidx1(v)
+ return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
case Op386MOVLstoreconstidx4:
- return rewriteValue386_Op386MOVLstoreconstidx4(v)
+ return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
case Op386MOVLstoreidx1:
- return rewriteValue386_Op386MOVLstoreidx1(v)
+ return rewriteValue386_Op386MOVLstoreidx1_0(v)
case Op386MOVLstoreidx4:
- return rewriteValue386_Op386MOVLstoreidx4(v)
+ return rewriteValue386_Op386MOVLstoreidx4_0(v)
case Op386MOVSDconst:
- return rewriteValue386_Op386MOVSDconst(v)
+ return rewriteValue386_Op386MOVSDconst_0(v)
case Op386MOVSDload:
- return rewriteValue386_Op386MOVSDload(v)
+ return rewriteValue386_Op386MOVSDload_0(v)
case Op386MOVSDloadidx1:
- return rewriteValue386_Op386MOVSDloadidx1(v)
+ return rewriteValue386_Op386MOVSDloadidx1_0(v)
case Op386MOVSDloadidx8:
- return rewriteValue386_Op386MOVSDloadidx8(v)
+ return rewriteValue386_Op386MOVSDloadidx8_0(v)
case Op386MOVSDstore:
- return rewriteValue386_Op386MOVSDstore(v)
+ return rewriteValue386_Op386MOVSDstore_0(v)
case Op386MOVSDstoreidx1:
- return rewriteValue386_Op386MOVSDstoreidx1(v)
+ return rewriteValue386_Op386MOVSDstoreidx1_0(v)
case Op386MOVSDstoreidx8:
- return rewriteValue386_Op386MOVSDstoreidx8(v)
+ return rewriteValue386_Op386MOVSDstoreidx8_0(v)
case Op386MOVSSconst:
- return rewriteValue386_Op386MOVSSconst(v)
+ return rewriteValue386_Op386MOVSSconst_0(v)
case Op386MOVSSload:
- return rewriteValue386_Op386MOVSSload(v)
+ return rewriteValue386_Op386MOVSSload_0(v)
case Op386MOVSSloadidx1:
- return rewriteValue386_Op386MOVSSloadidx1(v)
+ return rewriteValue386_Op386MOVSSloadidx1_0(v)
case Op386MOVSSloadidx4:
- return rewriteValue386_Op386MOVSSloadidx4(v)
+ return rewriteValue386_Op386MOVSSloadidx4_0(v)
case Op386MOVSSstore:
- return rewriteValue386_Op386MOVSSstore(v)
+ return rewriteValue386_Op386MOVSSstore_0(v)
case Op386MOVSSstoreidx1:
- return rewriteValue386_Op386MOVSSstoreidx1(v)
+ return rewriteValue386_Op386MOVSSstoreidx1_0(v)
case Op386MOVSSstoreidx4:
- return rewriteValue386_Op386MOVSSstoreidx4(v)
+ return rewriteValue386_Op386MOVSSstoreidx4_0(v)
case Op386MOVWLSX:
- return rewriteValue386_Op386MOVWLSX(v)
+ return rewriteValue386_Op386MOVWLSX_0(v)
case Op386MOVWLSXload:
- return rewriteValue386_Op386MOVWLSXload(v)
+ return rewriteValue386_Op386MOVWLSXload_0(v)
case Op386MOVWLZX:
- return rewriteValue386_Op386MOVWLZX(v)
+ return rewriteValue386_Op386MOVWLZX_0(v)
case Op386MOVWload:
- return rewriteValue386_Op386MOVWload(v)
+ return rewriteValue386_Op386MOVWload_0(v)
case Op386MOVWloadidx1:
- return rewriteValue386_Op386MOVWloadidx1(v)
+ return rewriteValue386_Op386MOVWloadidx1_0(v)
case Op386MOVWloadidx2:
- return rewriteValue386_Op386MOVWloadidx2(v)
+ return rewriteValue386_Op386MOVWloadidx2_0(v)
case Op386MOVWstore:
- return rewriteValue386_Op386MOVWstore(v)
+ return rewriteValue386_Op386MOVWstore_0(v)
case Op386MOVWstoreconst:
- return rewriteValue386_Op386MOVWstoreconst(v)
+ return rewriteValue386_Op386MOVWstoreconst_0(v)
case Op386MOVWstoreconstidx1:
- return rewriteValue386_Op386MOVWstoreconstidx1(v)
+ return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
case Op386MOVWstoreconstidx2:
- return rewriteValue386_Op386MOVWstoreconstidx2(v)
+ return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
case Op386MOVWstoreidx1:
- return rewriteValue386_Op386MOVWstoreidx1(v)
+ return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v)
case Op386MOVWstoreidx2:
- return rewriteValue386_Op386MOVWstoreidx2(v)
+ return rewriteValue386_Op386MOVWstoreidx2_0(v)
case Op386MULL:
- return rewriteValue386_Op386MULL(v)
+ return rewriteValue386_Op386MULL_0(v)
case Op386MULLconst:
- return rewriteValue386_Op386MULLconst(v)
+ return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v)
case Op386NEGL:
- return rewriteValue386_Op386NEGL(v)
+ return rewriteValue386_Op386NEGL_0(v)
case Op386NOTL:
- return rewriteValue386_Op386NOTL(v)
+ return rewriteValue386_Op386NOTL_0(v)
case Op386ORL:
- return rewriteValue386_Op386ORL(v)
+ return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v)
case Op386ORLconst:
- return rewriteValue386_Op386ORLconst(v)
+ return rewriteValue386_Op386ORLconst_0(v)
case Op386ROLBconst:
- return rewriteValue386_Op386ROLBconst(v)
+ return rewriteValue386_Op386ROLBconst_0(v)
case Op386ROLLconst:
- return rewriteValue386_Op386ROLLconst(v)
+ return rewriteValue386_Op386ROLLconst_0(v)
case Op386ROLWconst:
- return rewriteValue386_Op386ROLWconst(v)
+ return rewriteValue386_Op386ROLWconst_0(v)
case Op386SARB:
- return rewriteValue386_Op386SARB(v)
+ return rewriteValue386_Op386SARB_0(v)
case Op386SARBconst:
- return rewriteValue386_Op386SARBconst(v)
+ return rewriteValue386_Op386SARBconst_0(v)
case Op386SARL:
- return rewriteValue386_Op386SARL(v)
+ return rewriteValue386_Op386SARL_0(v)
case Op386SARLconst:
- return rewriteValue386_Op386SARLconst(v)
+ return rewriteValue386_Op386SARLconst_0(v)
case Op386SARW:
- return rewriteValue386_Op386SARW(v)
+ return rewriteValue386_Op386SARW_0(v)
case Op386SARWconst:
- return rewriteValue386_Op386SARWconst(v)
+ return rewriteValue386_Op386SARWconst_0(v)
case Op386SBBL:
- return rewriteValue386_Op386SBBL(v)
+ return rewriteValue386_Op386SBBL_0(v)
case Op386SBBLcarrymask:
- return rewriteValue386_Op386SBBLcarrymask(v)
+ return rewriteValue386_Op386SBBLcarrymask_0(v)
case Op386SETA:
- return rewriteValue386_Op386SETA(v)
+ return rewriteValue386_Op386SETA_0(v)
case Op386SETAE:
- return rewriteValue386_Op386SETAE(v)
+ return rewriteValue386_Op386SETAE_0(v)
case Op386SETB:
- return rewriteValue386_Op386SETB(v)
+ return rewriteValue386_Op386SETB_0(v)
case Op386SETBE:
- return rewriteValue386_Op386SETBE(v)
+ return rewriteValue386_Op386SETBE_0(v)
case Op386SETEQ:
- return rewriteValue386_Op386SETEQ(v)
+ return rewriteValue386_Op386SETEQ_0(v)
case Op386SETG:
- return rewriteValue386_Op386SETG(v)
+ return rewriteValue386_Op386SETG_0(v)
case Op386SETGE:
- return rewriteValue386_Op386SETGE(v)
+ return rewriteValue386_Op386SETGE_0(v)
case Op386SETL:
- return rewriteValue386_Op386SETL(v)
+ return rewriteValue386_Op386SETL_0(v)
case Op386SETLE:
- return rewriteValue386_Op386SETLE(v)
+ return rewriteValue386_Op386SETLE_0(v)
case Op386SETNE:
- return rewriteValue386_Op386SETNE(v)
+ return rewriteValue386_Op386SETNE_0(v)
case Op386SHLL:
- return rewriteValue386_Op386SHLL(v)
+ return rewriteValue386_Op386SHLL_0(v)
case Op386SHLLconst:
- return rewriteValue386_Op386SHLLconst(v)
+ return rewriteValue386_Op386SHLLconst_0(v)
case Op386SHRB:
- return rewriteValue386_Op386SHRB(v)
+ return rewriteValue386_Op386SHRB_0(v)
case Op386SHRBconst:
- return rewriteValue386_Op386SHRBconst(v)
+ return rewriteValue386_Op386SHRBconst_0(v)
case Op386SHRL:
- return rewriteValue386_Op386SHRL(v)
+ return rewriteValue386_Op386SHRL_0(v)
case Op386SHRLconst:
- return rewriteValue386_Op386SHRLconst(v)
+ return rewriteValue386_Op386SHRLconst_0(v)
case Op386SHRW:
- return rewriteValue386_Op386SHRW(v)
+ return rewriteValue386_Op386SHRW_0(v)
case Op386SHRWconst:
- return rewriteValue386_Op386SHRWconst(v)
+ return rewriteValue386_Op386SHRWconst_0(v)
case Op386SUBL:
- return rewriteValue386_Op386SUBL(v)
+ return rewriteValue386_Op386SUBL_0(v)
case Op386SUBLcarry:
- return rewriteValue386_Op386SUBLcarry(v)
+ return rewriteValue386_Op386SUBLcarry_0(v)
case Op386SUBLconst:
- return rewriteValue386_Op386SUBLconst(v)
+ return rewriteValue386_Op386SUBLconst_0(v)
case Op386XORL:
- return rewriteValue386_Op386XORL(v)
+ return rewriteValue386_Op386XORL_0(v)
case Op386XORLconst:
- return rewriteValue386_Op386XORLconst(v)
+ return rewriteValue386_Op386XORLconst_0(v)
case OpAdd16:
- return rewriteValue386_OpAdd16(v)
+ return rewriteValue386_OpAdd16_0(v)
case OpAdd32:
- return rewriteValue386_OpAdd32(v)
+ return rewriteValue386_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValue386_OpAdd32F(v)
+ return rewriteValue386_OpAdd32F_0(v)
case OpAdd32carry:
- return rewriteValue386_OpAdd32carry(v)
+ return rewriteValue386_OpAdd32carry_0(v)
case OpAdd32withcarry:
- return rewriteValue386_OpAdd32withcarry(v)
+ return rewriteValue386_OpAdd32withcarry_0(v)
case OpAdd64F:
- return rewriteValue386_OpAdd64F(v)
+ return rewriteValue386_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValue386_OpAdd8(v)
+ return rewriteValue386_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValue386_OpAddPtr(v)
+ return rewriteValue386_OpAddPtr_0(v)
case OpAddr:
- return rewriteValue386_OpAddr(v)
+ return rewriteValue386_OpAddr_0(v)
case OpAnd16:
- return rewriteValue386_OpAnd16(v)
+ return rewriteValue386_OpAnd16_0(v)
case OpAnd32:
- return rewriteValue386_OpAnd32(v)
+ return rewriteValue386_OpAnd32_0(v)
case OpAnd8:
- return rewriteValue386_OpAnd8(v)
+ return rewriteValue386_OpAnd8_0(v)
case OpAndB:
- return rewriteValue386_OpAndB(v)
+ return rewriteValue386_OpAndB_0(v)
case OpAvg32u:
- return rewriteValue386_OpAvg32u(v)
+ return rewriteValue386_OpAvg32u_0(v)
case OpBswap32:
- return rewriteValue386_OpBswap32(v)
+ return rewriteValue386_OpBswap32_0(v)
case OpClosureCall:
- return rewriteValue386_OpClosureCall(v)
+ return rewriteValue386_OpClosureCall_0(v)
case OpCom16:
- return rewriteValue386_OpCom16(v)
+ return rewriteValue386_OpCom16_0(v)
case OpCom32:
- return rewriteValue386_OpCom32(v)
+ return rewriteValue386_OpCom32_0(v)
case OpCom8:
- return rewriteValue386_OpCom8(v)
+ return rewriteValue386_OpCom8_0(v)
case OpConst16:
- return rewriteValue386_OpConst16(v)
+ return rewriteValue386_OpConst16_0(v)
case OpConst32:
- return rewriteValue386_OpConst32(v)
+ return rewriteValue386_OpConst32_0(v)
case OpConst32F:
- return rewriteValue386_OpConst32F(v)
+ return rewriteValue386_OpConst32F_0(v)
case OpConst64F:
- return rewriteValue386_OpConst64F(v)
+ return rewriteValue386_OpConst64F_0(v)
case OpConst8:
- return rewriteValue386_OpConst8(v)
+ return rewriteValue386_OpConst8_0(v)
case OpConstBool:
- return rewriteValue386_OpConstBool(v)
+ return rewriteValue386_OpConstBool_0(v)
case OpConstNil:
- return rewriteValue386_OpConstNil(v)
+ return rewriteValue386_OpConstNil_0(v)
case OpConvert:
- return rewriteValue386_OpConvert(v)
+ return rewriteValue386_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValue386_OpCvt32Fto32(v)
+ return rewriteValue386_OpCvt32Fto32_0(v)
case OpCvt32Fto64F:
- return rewriteValue386_OpCvt32Fto64F(v)
+ return rewriteValue386_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValue386_OpCvt32to32F(v)
+ return rewriteValue386_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValue386_OpCvt32to64F(v)
+ return rewriteValue386_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValue386_OpCvt64Fto32(v)
+ return rewriteValue386_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValue386_OpCvt64Fto32F(v)
+ return rewriteValue386_OpCvt64Fto32F_0(v)
case OpDiv16:
- return rewriteValue386_OpDiv16(v)
+ return rewriteValue386_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValue386_OpDiv16u(v)
+ return rewriteValue386_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValue386_OpDiv32(v)
+ return rewriteValue386_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValue386_OpDiv32F(v)
+ return rewriteValue386_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValue386_OpDiv32u(v)
+ return rewriteValue386_OpDiv32u_0(v)
case OpDiv64F:
- return rewriteValue386_OpDiv64F(v)
+ return rewriteValue386_OpDiv64F_0(v)
case OpDiv8:
- return rewriteValue386_OpDiv8(v)
+ return rewriteValue386_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValue386_OpDiv8u(v)
+ return rewriteValue386_OpDiv8u_0(v)
case OpEq16:
- return rewriteValue386_OpEq16(v)
+ return rewriteValue386_OpEq16_0(v)
case OpEq32:
- return rewriteValue386_OpEq32(v)
+ return rewriteValue386_OpEq32_0(v)
case OpEq32F:
- return rewriteValue386_OpEq32F(v)
+ return rewriteValue386_OpEq32F_0(v)
case OpEq64F:
- return rewriteValue386_OpEq64F(v)
+ return rewriteValue386_OpEq64F_0(v)
case OpEq8:
- return rewriteValue386_OpEq8(v)
+ return rewriteValue386_OpEq8_0(v)
case OpEqB:
- return rewriteValue386_OpEqB(v)
+ return rewriteValue386_OpEqB_0(v)
case OpEqPtr:
- return rewriteValue386_OpEqPtr(v)
+ return rewriteValue386_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValue386_OpGeq16(v)
+ return rewriteValue386_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValue386_OpGeq16U(v)
+ return rewriteValue386_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValue386_OpGeq32(v)
+ return rewriteValue386_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValue386_OpGeq32F(v)
+ return rewriteValue386_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValue386_OpGeq32U(v)
+ return rewriteValue386_OpGeq32U_0(v)
case OpGeq64F:
- return rewriteValue386_OpGeq64F(v)
+ return rewriteValue386_OpGeq64F_0(v)
case OpGeq8:
- return rewriteValue386_OpGeq8(v)
+ return rewriteValue386_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValue386_OpGeq8U(v)
+ return rewriteValue386_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValue386_OpGetClosurePtr(v)
+ return rewriteValue386_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValue386_OpGetG(v)
+ return rewriteValue386_OpGetG_0(v)
case OpGreater16:
- return rewriteValue386_OpGreater16(v)
+ return rewriteValue386_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValue386_OpGreater16U(v)
+ return rewriteValue386_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValue386_OpGreater32(v)
+ return rewriteValue386_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValue386_OpGreater32F(v)
+ return rewriteValue386_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValue386_OpGreater32U(v)
+ return rewriteValue386_OpGreater32U_0(v)
case OpGreater64F:
- return rewriteValue386_OpGreater64F(v)
+ return rewriteValue386_OpGreater64F_0(v)
case OpGreater8:
- return rewriteValue386_OpGreater8(v)
+ return rewriteValue386_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValue386_OpGreater8U(v)
+ return rewriteValue386_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValue386_OpHmul32(v)
+ return rewriteValue386_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValue386_OpHmul32u(v)
+ return rewriteValue386_OpHmul32u_0(v)
case OpInterCall:
- return rewriteValue386_OpInterCall(v)
+ return rewriteValue386_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValue386_OpIsInBounds(v)
+ return rewriteValue386_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValue386_OpIsNonNil(v)
+ return rewriteValue386_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValue386_OpIsSliceInBounds(v)
+ return rewriteValue386_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValue386_OpLeq16(v)
+ return rewriteValue386_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValue386_OpLeq16U(v)
+ return rewriteValue386_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValue386_OpLeq32(v)
+ return rewriteValue386_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValue386_OpLeq32F(v)
+ return rewriteValue386_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValue386_OpLeq32U(v)
+ return rewriteValue386_OpLeq32U_0(v)
case OpLeq64F:
- return rewriteValue386_OpLeq64F(v)
+ return rewriteValue386_OpLeq64F_0(v)
case OpLeq8:
- return rewriteValue386_OpLeq8(v)
+ return rewriteValue386_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValue386_OpLeq8U(v)
+ return rewriteValue386_OpLeq8U_0(v)
case OpLess16:
- return rewriteValue386_OpLess16(v)
+ return rewriteValue386_OpLess16_0(v)
case OpLess16U:
- return rewriteValue386_OpLess16U(v)
+ return rewriteValue386_OpLess16U_0(v)
case OpLess32:
- return rewriteValue386_OpLess32(v)
+ return rewriteValue386_OpLess32_0(v)
case OpLess32F:
- return rewriteValue386_OpLess32F(v)
+ return rewriteValue386_OpLess32F_0(v)
case OpLess32U:
- return rewriteValue386_OpLess32U(v)
+ return rewriteValue386_OpLess32U_0(v)
case OpLess64F:
- return rewriteValue386_OpLess64F(v)
+ return rewriteValue386_OpLess64F_0(v)
case OpLess8:
- return rewriteValue386_OpLess8(v)
+ return rewriteValue386_OpLess8_0(v)
case OpLess8U:
- return rewriteValue386_OpLess8U(v)
+ return rewriteValue386_OpLess8U_0(v)
case OpLoad:
- return rewriteValue386_OpLoad(v)
+ return rewriteValue386_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValue386_OpLsh16x16(v)
+ return rewriteValue386_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValue386_OpLsh16x32(v)
+ return rewriteValue386_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValue386_OpLsh16x64(v)
+ return rewriteValue386_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValue386_OpLsh16x8(v)
+ return rewriteValue386_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValue386_OpLsh32x16(v)
+ return rewriteValue386_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValue386_OpLsh32x32(v)
+ return rewriteValue386_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValue386_OpLsh32x64(v)
+ return rewriteValue386_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValue386_OpLsh32x8(v)
+ return rewriteValue386_OpLsh32x8_0(v)
case OpLsh8x16:
- return rewriteValue386_OpLsh8x16(v)
+ return rewriteValue386_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValue386_OpLsh8x32(v)
+ return rewriteValue386_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValue386_OpLsh8x64(v)
+ return rewriteValue386_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValue386_OpLsh8x8(v)
+ return rewriteValue386_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValue386_OpMod16(v)
+ return rewriteValue386_OpMod16_0(v)
case OpMod16u:
- return rewriteValue386_OpMod16u(v)
+ return rewriteValue386_OpMod16u_0(v)
case OpMod32:
- return rewriteValue386_OpMod32(v)
+ return rewriteValue386_OpMod32_0(v)
case OpMod32u:
- return rewriteValue386_OpMod32u(v)
+ return rewriteValue386_OpMod32u_0(v)
case OpMod8:
- return rewriteValue386_OpMod8(v)
+ return rewriteValue386_OpMod8_0(v)
case OpMod8u:
- return rewriteValue386_OpMod8u(v)
+ return rewriteValue386_OpMod8u_0(v)
case OpMove:
- return rewriteValue386_OpMove(v)
+ return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
case OpMul16:
- return rewriteValue386_OpMul16(v)
+ return rewriteValue386_OpMul16_0(v)
case OpMul32:
- return rewriteValue386_OpMul32(v)
+ return rewriteValue386_OpMul32_0(v)
case OpMul32F:
- return rewriteValue386_OpMul32F(v)
+ return rewriteValue386_OpMul32F_0(v)
case OpMul32uhilo:
- return rewriteValue386_OpMul32uhilo(v)
+ return rewriteValue386_OpMul32uhilo_0(v)
case OpMul64F:
- return rewriteValue386_OpMul64F(v)
+ return rewriteValue386_OpMul64F_0(v)
case OpMul8:
- return rewriteValue386_OpMul8(v)
+ return rewriteValue386_OpMul8_0(v)
case OpNeg16:
- return rewriteValue386_OpNeg16(v)
+ return rewriteValue386_OpNeg16_0(v)
case OpNeg32:
- return rewriteValue386_OpNeg32(v)
+ return rewriteValue386_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValue386_OpNeg32F(v)
+ return rewriteValue386_OpNeg32F_0(v)
case OpNeg64F:
- return rewriteValue386_OpNeg64F(v)
+ return rewriteValue386_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValue386_OpNeg8(v)
+ return rewriteValue386_OpNeg8_0(v)
case OpNeq16:
- return rewriteValue386_OpNeq16(v)
+ return rewriteValue386_OpNeq16_0(v)
case OpNeq32:
- return rewriteValue386_OpNeq32(v)
+ return rewriteValue386_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValue386_OpNeq32F(v)
+ return rewriteValue386_OpNeq32F_0(v)
case OpNeq64F:
- return rewriteValue386_OpNeq64F(v)
+ return rewriteValue386_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValue386_OpNeq8(v)
+ return rewriteValue386_OpNeq8_0(v)
case OpNeqB:
- return rewriteValue386_OpNeqB(v)
+ return rewriteValue386_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValue386_OpNeqPtr(v)
+ return rewriteValue386_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValue386_OpNilCheck(v)
+ return rewriteValue386_OpNilCheck_0(v)
case OpNot:
- return rewriteValue386_OpNot(v)
+ return rewriteValue386_OpNot_0(v)
case OpOffPtr:
- return rewriteValue386_OpOffPtr(v)
+ return rewriteValue386_OpOffPtr_0(v)
case OpOr16:
- return rewriteValue386_OpOr16(v)
+ return rewriteValue386_OpOr16_0(v)
case OpOr32:
- return rewriteValue386_OpOr32(v)
+ return rewriteValue386_OpOr32_0(v)
case OpOr8:
- return rewriteValue386_OpOr8(v)
+ return rewriteValue386_OpOr8_0(v)
case OpOrB:
- return rewriteValue386_OpOrB(v)
+ return rewriteValue386_OpOrB_0(v)
case OpRound32F:
- return rewriteValue386_OpRound32F(v)
+ return rewriteValue386_OpRound32F_0(v)
case OpRound64F:
- return rewriteValue386_OpRound64F(v)
+ return rewriteValue386_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValue386_OpRsh16Ux16(v)
+ return rewriteValue386_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValue386_OpRsh16Ux32(v)
+ return rewriteValue386_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValue386_OpRsh16Ux64(v)
+ return rewriteValue386_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValue386_OpRsh16Ux8(v)
+ return rewriteValue386_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValue386_OpRsh16x16(v)
+ return rewriteValue386_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValue386_OpRsh16x32(v)
+ return rewriteValue386_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValue386_OpRsh16x64(v)
+ return rewriteValue386_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValue386_OpRsh16x8(v)
+ return rewriteValue386_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValue386_OpRsh32Ux16(v)
+ return rewriteValue386_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValue386_OpRsh32Ux32(v)
+ return rewriteValue386_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValue386_OpRsh32Ux64(v)
+ return rewriteValue386_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValue386_OpRsh32Ux8(v)
+ return rewriteValue386_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValue386_OpRsh32x16(v)
+ return rewriteValue386_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValue386_OpRsh32x32(v)
+ return rewriteValue386_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValue386_OpRsh32x64(v)
+ return rewriteValue386_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValue386_OpRsh32x8(v)
+ return rewriteValue386_OpRsh32x8_0(v)
case OpRsh8Ux16:
- return rewriteValue386_OpRsh8Ux16(v)
+ return rewriteValue386_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValue386_OpRsh8Ux32(v)
+ return rewriteValue386_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValue386_OpRsh8Ux64(v)
+ return rewriteValue386_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValue386_OpRsh8Ux8(v)
+ return rewriteValue386_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValue386_OpRsh8x16(v)
+ return rewriteValue386_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValue386_OpRsh8x32(v)
+ return rewriteValue386_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValue386_OpRsh8x64(v)
+ return rewriteValue386_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValue386_OpRsh8x8(v)
+ return rewriteValue386_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValue386_OpSignExt16to32(v)
+ return rewriteValue386_OpSignExt16to32_0(v)
case OpSignExt8to16:
- return rewriteValue386_OpSignExt8to16(v)
+ return rewriteValue386_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValue386_OpSignExt8to32(v)
+ return rewriteValue386_OpSignExt8to32_0(v)
case OpSignmask:
- return rewriteValue386_OpSignmask(v)
+ return rewriteValue386_OpSignmask_0(v)
case OpSlicemask:
- return rewriteValue386_OpSlicemask(v)
+ return rewriteValue386_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValue386_OpSqrt(v)
+ return rewriteValue386_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValue386_OpStaticCall(v)
+ return rewriteValue386_OpStaticCall_0(v)
case OpStore:
- return rewriteValue386_OpStore(v)
+ return rewriteValue386_OpStore_0(v)
case OpSub16:
- return rewriteValue386_OpSub16(v)
+ return rewriteValue386_OpSub16_0(v)
case OpSub32:
- return rewriteValue386_OpSub32(v)
+ return rewriteValue386_OpSub32_0(v)
case OpSub32F:
- return rewriteValue386_OpSub32F(v)
+ return rewriteValue386_OpSub32F_0(v)
case OpSub32carry:
- return rewriteValue386_OpSub32carry(v)
+ return rewriteValue386_OpSub32carry_0(v)
case OpSub32withcarry:
- return rewriteValue386_OpSub32withcarry(v)
+ return rewriteValue386_OpSub32withcarry_0(v)
case OpSub64F:
- return rewriteValue386_OpSub64F(v)
+ return rewriteValue386_OpSub64F_0(v)
case OpSub8:
- return rewriteValue386_OpSub8(v)
+ return rewriteValue386_OpSub8_0(v)
case OpSubPtr:
- return rewriteValue386_OpSubPtr(v)
+ return rewriteValue386_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValue386_OpTrunc16to8(v)
+ return rewriteValue386_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValue386_OpTrunc32to16(v)
+ return rewriteValue386_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValue386_OpTrunc32to8(v)
+ return rewriteValue386_OpTrunc32to8_0(v)
case OpXor16:
- return rewriteValue386_OpXor16(v)
+ return rewriteValue386_OpXor16_0(v)
case OpXor32:
- return rewriteValue386_OpXor32(v)
+ return rewriteValue386_OpXor32_0(v)
case OpXor8:
- return rewriteValue386_OpXor8(v)
+ return rewriteValue386_OpXor8_0(v)
case OpZero:
- return rewriteValue386_OpZero(v)
+ return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValue386_OpZeroExt16to32(v)
+ return rewriteValue386_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
- return rewriteValue386_OpZeroExt8to16(v)
+ return rewriteValue386_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValue386_OpZeroExt8to32(v)
+ return rewriteValue386_OpZeroExt8to32_0(v)
case OpZeromask:
- return rewriteValue386_OpZeromask(v)
+ return rewriteValue386_OpZeromask_0(v)
}
return false
}
-func rewriteValue386_Op386ADCL(v *Value) bool {
+func rewriteValue386_Op386ADCL_0(v *Value) bool {
// match: (ADCL x (MOVLconst [c]) f)
// cond:
// result: (ADCLconst [c] x f)
@@ -661,7 +661,7 @@
}
return false
}
-func rewriteValue386_Op386ADDL(v *Value) bool {
+func rewriteValue386_Op386ADDL_0(v *Value) bool {
// match: (ADDL x (MOVLconst [c]))
// cond:
// result: (ADDLconst [c] x)
@@ -888,6 +888,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValue386_Op386ADDL_10(v *Value) bool {
// match: (ADDL x (SHLLconst [2] y))
// cond:
// result: (LEAL4 x y)
@@ -1068,6 +1071,9 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValue386_Op386ADDL_20(v *Value) bool {
// match: (ADDL (ADDLconst [c] x) y)
// cond:
// result: (LEAL1 [c] x y)
@@ -1178,7 +1184,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLcarry(v *Value) bool {
+func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
// match: (ADDLcarry x (MOVLconst [c]))
// cond:
// result: (ADDLconstcarry [c] x)
@@ -1211,7 +1217,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconst(v *Value) bool {
+func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
// match: (ADDLconst [c] (ADDL x y))
// cond:
// result: (LEAL1 [c] x y)
@@ -1388,7 +1394,7 @@
}
return false
}
-func rewriteValue386_Op386ANDL(v *Value) bool {
+func rewriteValue386_Op386ANDL_0(v *Value) bool {
// match: (ANDL x (MOVLconst [c]))
// cond:
// result: (ANDLconst [c] x)
@@ -1434,7 +1440,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconst(v *Value) bool {
+func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
// match: (ANDLconst [c] (ANDLconst [d] x))
// cond:
// result: (ANDLconst [c & d] x)
@@ -1493,7 +1499,7 @@
}
return false
}
-func rewriteValue386_Op386CMPB(v *Value) bool {
+func rewriteValue386_Op386CMPB_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPB x (MOVLconst [c]))
@@ -1530,7 +1536,7 @@
}
return false
}
-func rewriteValue386_Op386CMPBconst(v *Value) bool {
+func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
// match: (CMPBconst (MOVLconst [x]) [y])
// cond: int8(x)==int8(y)
// result: (FlagEQ)
@@ -1678,7 +1684,7 @@
}
return false
}
-func rewriteValue386_Op386CMPL(v *Value) bool {
+func rewriteValue386_Op386CMPL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPL x (MOVLconst [c]))
@@ -1715,7 +1721,7 @@
}
return false
}
-func rewriteValue386_Op386CMPLconst(v *Value) bool {
+func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -1879,7 +1885,7 @@
}
return false
}
-func rewriteValue386_Op386CMPW(v *Value) bool {
+func rewriteValue386_Op386CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVLconst [c]))
@@ -1916,7 +1922,7 @@
}
return false
}
-func rewriteValue386_Op386CMPWconst(v *Value) bool {
+func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVLconst [x]) [y])
// cond: int16(x)==int16(y)
// result: (FlagEQ)
@@ -2064,7 +2070,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL(v *Value) bool {
+func rewriteValue386_Op386LEAL_0(v *Value) bool {
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAL [c+d] {s} x)
@@ -2228,7 +2234,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL1(v *Value) bool {
+func rewriteValue386_Op386LEAL1_0(v *Value) bool {
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL1 [c+d] {s} x y)
@@ -2457,7 +2463,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL2(v *Value) bool {
+func rewriteValue386_Op386LEAL2_0(v *Value) bool {
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL2 [c+d] {s} x y)
@@ -2574,7 +2580,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL4(v *Value) bool {
+func rewriteValue386_Op386LEAL4_0(v *Value) bool {
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL4 [c+d] {s} x y)
@@ -2669,7 +2675,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL8(v *Value) bool {
+func rewriteValue386_Op386LEAL8_0(v *Value) bool {
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL8 [c+d] {s} x y)
@@ -2742,7 +2748,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSX(v *Value) bool {
+func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
@@ -2790,7 +2796,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -2821,7 +2827,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLZX(v *Value) bool {
+func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
@@ -2893,7 +2899,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBload(v *Value) bool {
+func rewriteValue386_Op386MOVBload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -3020,7 +3026,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
// match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
@@ -3111,7 +3117,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstore(v *Value) bool {
+func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -3379,7 +3385,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -3509,7 +3515,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
// match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
// cond:
// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -3590,7 +3596,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
// match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -3985,6 +3991,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool {
// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
@@ -4093,7 +4102,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLload(v *Value) bool {
+func rewriteValue386_Op386MOVLload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -4246,7 +4255,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
// match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
// cond:
// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
@@ -4385,7 +4394,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
// match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
@@ -4432,7 +4441,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstore(v *Value) bool {
+func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -4595,7 +4604,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -4722,7 +4731,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
// cond:
// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
@@ -4793,7 +4802,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
// match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem)
// cond:
// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -4840,7 +4849,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
// match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem)
// cond:
// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
@@ -4991,7 +5000,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
// match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -5042,7 +5051,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDconst(v *Value) bool {
+func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5065,7 +5074,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDload(v *Value) bool {
+func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5195,7 +5204,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
// match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx1 [c+d] {sym} ptr idx mem)
@@ -5242,7 +5251,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
// match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
@@ -5289,7 +5298,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstore(v *Value) bool {
+func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5429,7 +5438,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
// match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -5480,7 +5489,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
// match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -5531,7 +5540,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSconst(v *Value) bool {
+func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5554,7 +5563,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSload(v *Value) bool {
+func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5684,7 +5693,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
// match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx1 [c+d] {sym} ptr idx mem)
@@ -5731,7 +5740,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
// match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
@@ -5778,7 +5787,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstore(v *Value) bool {
+func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -5918,7 +5927,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
// match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx1 [c+d] {sym} ptr idx val mem)
@@ -5969,7 +5978,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
// match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -6020,7 +6029,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSX(v *Value) bool {
+func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
@@ -6068,7 +6077,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -6099,7 +6108,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLZX(v *Value) bool {
+func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
@@ -6198,7 +6207,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWload(v *Value) bool {
+func rewriteValue386_Op386MOVWload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -6351,7 +6360,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
// match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
// cond:
// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
@@ -6490,7 +6499,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWloadidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
// match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
@@ -6537,7 +6546,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstore(v *Value) bool {
+func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -6833,7 +6842,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -6989,7 +6998,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
// cond:
// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
@@ -7094,7 +7103,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem)
@@ -7180,7 +7189,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
// match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem)
// cond:
// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
@@ -7521,6 +7530,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool {
// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
@@ -7735,7 +7747,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem)
@@ -7895,7 +7907,7 @@
}
return false
}
-func rewriteValue386_Op386MULL(v *Value) bool {
+func rewriteValue386_Op386MULL_0(v *Value) bool {
// match: (MULL x (MOVLconst [c]))
// cond:
// result: (MULLconst [c] x)
@@ -7928,7 +7940,7 @@
}
return false
}
-func rewriteValue386_Op386MULLconst(v *Value) bool {
+func rewriteValue386_Op386MULLconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLconst [c] (MULLconst [d] x))
@@ -8069,6 +8081,11 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValue386_Op386MULLconst_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULLconst [21] x)
// cond:
// result: (LEAL4 x (LEAL4 <v.Type> x x))
@@ -8231,6 +8248,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValue386_Op386MULLconst_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULLconst [c] x)
// cond: isPowerOfTwo(c-8) && c >= 136
// result: (LEAL8 (SHLLconst <v.Type> [log2(c-8)] x) x)
@@ -8315,7 +8337,7 @@
}
return false
}
-func rewriteValue386_Op386NEGL(v *Value) bool {
+func rewriteValue386_Op386NEGL_0(v *Value) bool {
// match: (NEGL (MOVLconst [c]))
// cond:
// result: (MOVLconst [int64(int32(-c))])
@@ -8331,7 +8353,7 @@
}
return false
}
-func rewriteValue386_Op386NOTL(v *Value) bool {
+func rewriteValue386_Op386NOTL_0(v *Value) bool {
// match: (NOTL (MOVLconst [c]))
// cond:
// result: (MOVLconst [^c])
@@ -8347,7 +8369,7 @@
}
return false
}
-func rewriteValue386_Op386ORL(v *Value) bool {
+func rewriteValue386_Op386ORL_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8601,6 +8623,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)
// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
@@ -9186,6 +9215,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
// cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -9892,6 +9926,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_30(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -10682,6 +10721,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_40(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -11472,6 +11516,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_50(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -11869,7 +11918,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconst(v *Value) bool {
+func rewriteValue386_Op386ORLconst_0(v *Value) bool {
// match: (ORLconst [c] x)
// cond: int32(c)==0
// result: x
@@ -11912,7 +11961,7 @@
}
return false
}
-func rewriteValue386_Op386ROLBconst(v *Value) bool {
+func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
// match: (ROLBconst [c] (ROLBconst [d] x))
// cond:
// result: (ROLBconst [(c+d)& 7] x)
@@ -11944,7 +11993,7 @@
}
return false
}
-func rewriteValue386_Op386ROLLconst(v *Value) bool {
+func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
// match: (ROLLconst [c] (ROLLconst [d] x))
// cond:
// result: (ROLLconst [(c+d)&31] x)
@@ -11976,7 +12025,7 @@
}
return false
}
-func rewriteValue386_Op386ROLWconst(v *Value) bool {
+func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
// match: (ROLWconst [c] (ROLWconst [d] x))
// cond:
// result: (ROLWconst [(c+d)&15] x)
@@ -12008,7 +12057,7 @@
}
return false
}
-func rewriteValue386_Op386SARB(v *Value) bool {
+func rewriteValue386_Op386SARB_0(v *Value) bool {
// match: (SARB x (MOVLconst [c]))
// cond:
// result: (SARBconst [min(c&31,7)] x)
@@ -12026,7 +12075,7 @@
}
return false
}
-func rewriteValue386_Op386SARBconst(v *Value) bool {
+func rewriteValue386_Op386SARBconst_0(v *Value) bool {
// match: (SARBconst x [0])
// cond:
// result: x
@@ -12056,7 +12105,7 @@
}
return false
}
-func rewriteValue386_Op386SARL(v *Value) bool {
+func rewriteValue386_Op386SARL_0(v *Value) bool {
// match: (SARL x (MOVLconst [c]))
// cond:
// result: (SARLconst [c&31] x)
@@ -12092,7 +12141,7 @@
}
return false
}
-func rewriteValue386_Op386SARLconst(v *Value) bool {
+func rewriteValue386_Op386SARLconst_0(v *Value) bool {
// match: (SARLconst x [0])
// cond:
// result: x
@@ -12122,7 +12171,7 @@
}
return false
}
-func rewriteValue386_Op386SARW(v *Value) bool {
+func rewriteValue386_Op386SARW_0(v *Value) bool {
// match: (SARW x (MOVLconst [c]))
// cond:
// result: (SARWconst [min(c&31,15)] x)
@@ -12140,7 +12189,7 @@
}
return false
}
-func rewriteValue386_Op386SARWconst(v *Value) bool {
+func rewriteValue386_Op386SARWconst_0(v *Value) bool {
// match: (SARWconst x [0])
// cond:
// result: x
@@ -12170,7 +12219,7 @@
}
return false
}
-func rewriteValue386_Op386SBBL(v *Value) bool {
+func rewriteValue386_Op386SBBL_0(v *Value) bool {
// match: (SBBL x (MOVLconst [c]) f)
// cond:
// result: (SBBLconst [c] x f)
@@ -12190,7 +12239,7 @@
}
return false
}
-func rewriteValue386_Op386SBBLcarrymask(v *Value) bool {
+func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
// match: (SBBLcarrymask (FlagEQ))
// cond:
// result: (MOVLconst [0])
@@ -12253,7 +12302,7 @@
}
return false
}
-func rewriteValue386_Op386SETA(v *Value) bool {
+func rewriteValue386_Op386SETA_0(v *Value) bool {
// match: (SETA (InvertFlags x))
// cond:
// result: (SETB x)
@@ -12329,7 +12378,7 @@
}
return false
}
-func rewriteValue386_Op386SETAE(v *Value) bool {
+func rewriteValue386_Op386SETAE_0(v *Value) bool {
// match: (SETAE (InvertFlags x))
// cond:
// result: (SETBE x)
@@ -12405,7 +12454,7 @@
}
return false
}
-func rewriteValue386_Op386SETB(v *Value) bool {
+func rewriteValue386_Op386SETB_0(v *Value) bool {
// match: (SETB (InvertFlags x))
// cond:
// result: (SETA x)
@@ -12481,7 +12530,7 @@
}
return false
}
-func rewriteValue386_Op386SETBE(v *Value) bool {
+func rewriteValue386_Op386SETBE_0(v *Value) bool {
// match: (SETBE (InvertFlags x))
// cond:
// result: (SETAE x)
@@ -12557,7 +12606,7 @@
}
return false
}
-func rewriteValue386_Op386SETEQ(v *Value) bool {
+func rewriteValue386_Op386SETEQ_0(v *Value) bool {
// match: (SETEQ (InvertFlags x))
// cond:
// result: (SETEQ x)
@@ -12633,7 +12682,7 @@
}
return false
}
-func rewriteValue386_Op386SETG(v *Value) bool {
+func rewriteValue386_Op386SETG_0(v *Value) bool {
// match: (SETG (InvertFlags x))
// cond:
// result: (SETL x)
@@ -12709,7 +12758,7 @@
}
return false
}
-func rewriteValue386_Op386SETGE(v *Value) bool {
+func rewriteValue386_Op386SETGE_0(v *Value) bool {
// match: (SETGE (InvertFlags x))
// cond:
// result: (SETLE x)
@@ -12785,7 +12834,7 @@
}
return false
}
-func rewriteValue386_Op386SETL(v *Value) bool {
+func rewriteValue386_Op386SETL_0(v *Value) bool {
// match: (SETL (InvertFlags x))
// cond:
// result: (SETG x)
@@ -12861,7 +12910,7 @@
}
return false
}
-func rewriteValue386_Op386SETLE(v *Value) bool {
+func rewriteValue386_Op386SETLE_0(v *Value) bool {
// match: (SETLE (InvertFlags x))
// cond:
// result: (SETGE x)
@@ -12937,7 +12986,7 @@
}
return false
}
-func rewriteValue386_Op386SETNE(v *Value) bool {
+func rewriteValue386_Op386SETNE_0(v *Value) bool {
// match: (SETNE (InvertFlags x))
// cond:
// result: (SETNE x)
@@ -13013,7 +13062,7 @@
}
return false
}
-func rewriteValue386_Op386SHLL(v *Value) bool {
+func rewriteValue386_Op386SHLL_0(v *Value) bool {
// match: (SHLL x (MOVLconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
@@ -13049,7 +13098,7 @@
}
return false
}
-func rewriteValue386_Op386SHLLconst(v *Value) bool {
+func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
// match: (SHLLconst x [0])
// cond:
// result: x
@@ -13065,7 +13114,7 @@
}
return false
}
-func rewriteValue386_Op386SHRB(v *Value) bool {
+func rewriteValue386_Op386SHRB_0(v *Value) bool {
// match: (SHRB x (MOVLconst [c]))
// cond: c&31 < 8
// result: (SHRBconst [c&31] x)
@@ -13102,7 +13151,7 @@
}
return false
}
-func rewriteValue386_Op386SHRBconst(v *Value) bool {
+func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
// match: (SHRBconst x [0])
// cond:
// result: x
@@ -13118,7 +13167,7 @@
}
return false
}
-func rewriteValue386_Op386SHRL(v *Value) bool {
+func rewriteValue386_Op386SHRL_0(v *Value) bool {
// match: (SHRL x (MOVLconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
@@ -13154,7 +13203,7 @@
}
return false
}
-func rewriteValue386_Op386SHRLconst(v *Value) bool {
+func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
// match: (SHRLconst x [0])
// cond:
// result: x
@@ -13170,7 +13219,7 @@
}
return false
}
-func rewriteValue386_Op386SHRW(v *Value) bool {
+func rewriteValue386_Op386SHRW_0(v *Value) bool {
// match: (SHRW x (MOVLconst [c]))
// cond: c&31 < 16
// result: (SHRWconst [c&31] x)
@@ -13207,7 +13256,7 @@
}
return false
}
-func rewriteValue386_Op386SHRWconst(v *Value) bool {
+func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
// match: (SHRWconst x [0])
// cond:
// result: x
@@ -13223,7 +13272,7 @@
}
return false
}
-func rewriteValue386_Op386SUBL(v *Value) bool {
+func rewriteValue386_Op386SUBL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBL x (MOVLconst [c]))
@@ -13272,7 +13321,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLcarry(v *Value) bool {
+func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
// match: (SUBLcarry x (MOVLconst [c]))
// cond:
// result: (SUBLconstcarry [c] x)
@@ -13290,7 +13339,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLconst(v *Value) bool {
+func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
// result: x
@@ -13317,7 +13366,7 @@
return true
}
}
-func rewriteValue386_Op386XORL(v *Value) bool {
+func rewriteValue386_Op386XORL_0(v *Value) bool {
// match: (XORL x (MOVLconst [c]))
// cond:
// result: (XORLconst [c] x)
@@ -13522,7 +13571,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconst(v *Value) bool {
+func rewriteValue386_Op386XORLconst_0(v *Value) bool {
// match: (XORLconst [c] (XORLconst [d] x))
// cond:
// result: (XORLconst [c ^ d] x)
@@ -13569,7 +13618,7 @@
}
return false
}
-func rewriteValue386_OpAdd16(v *Value) bool {
+func rewriteValue386_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDL x y)
@@ -13582,7 +13631,7 @@
return true
}
}
-func rewriteValue386_OpAdd32(v *Value) bool {
+func rewriteValue386_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDL x y)
@@ -13595,7 +13644,7 @@
return true
}
}
-func rewriteValue386_OpAdd32F(v *Value) bool {
+func rewriteValue386_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDSS x y)
@@ -13608,7 +13657,7 @@
return true
}
}
-func rewriteValue386_OpAdd32carry(v *Value) bool {
+func rewriteValue386_OpAdd32carry_0(v *Value) bool {
// match: (Add32carry x y)
// cond:
// result: (ADDLcarry x y)
@@ -13621,7 +13670,7 @@
return true
}
}
-func rewriteValue386_OpAdd32withcarry(v *Value) bool {
+func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
// match: (Add32withcarry x y c)
// cond:
// result: (ADCL x y c)
@@ -13636,7 +13685,7 @@
return true
}
}
-func rewriteValue386_OpAdd64F(v *Value) bool {
+func rewriteValue386_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDSD x y)
@@ -13649,7 +13698,7 @@
return true
}
}
-func rewriteValue386_OpAdd8(v *Value) bool {
+func rewriteValue386_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDL x y)
@@ -13662,7 +13711,7 @@
return true
}
}
-func rewriteValue386_OpAddPtr(v *Value) bool {
+func rewriteValue386_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADDL x y)
@@ -13675,7 +13724,7 @@
return true
}
}
-func rewriteValue386_OpAddr(v *Value) bool {
+func rewriteValue386_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (LEAL {sym} base)
@@ -13688,7 +13737,7 @@
return true
}
}
-func rewriteValue386_OpAnd16(v *Value) bool {
+func rewriteValue386_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDL x y)
@@ -13701,7 +13750,7 @@
return true
}
}
-func rewriteValue386_OpAnd32(v *Value) bool {
+func rewriteValue386_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDL x y)
@@ -13714,7 +13763,7 @@
return true
}
}
-func rewriteValue386_OpAnd8(v *Value) bool {
+func rewriteValue386_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDL x y)
@@ -13727,7 +13776,7 @@
return true
}
}
-func rewriteValue386_OpAndB(v *Value) bool {
+func rewriteValue386_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDL x y)
@@ -13740,7 +13789,7 @@
return true
}
}
-func rewriteValue386_OpAvg32u(v *Value) bool {
+func rewriteValue386_OpAvg32u_0(v *Value) bool {
// match: (Avg32u x y)
// cond:
// result: (AVGLU x y)
@@ -13753,7 +13802,7 @@
return true
}
}
-func rewriteValue386_OpBswap32(v *Value) bool {
+func rewriteValue386_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (BSWAPL x)
@@ -13764,7 +13813,7 @@
return true
}
}
-func rewriteValue386_OpClosureCall(v *Value) bool {
+func rewriteValue386_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -13781,7 +13830,7 @@
return true
}
}
-func rewriteValue386_OpCom16(v *Value) bool {
+func rewriteValue386_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTL x)
@@ -13792,7 +13841,7 @@
return true
}
}
-func rewriteValue386_OpCom32(v *Value) bool {
+func rewriteValue386_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTL x)
@@ -13803,7 +13852,7 @@
return true
}
}
-func rewriteValue386_OpCom8(v *Value) bool {
+func rewriteValue386_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTL x)
@@ -13814,7 +13863,7 @@
return true
}
}
-func rewriteValue386_OpConst16(v *Value) bool {
+func rewriteValue386_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVLconst [val])
@@ -13825,7 +13874,7 @@
return true
}
}
-func rewriteValue386_OpConst32(v *Value) bool {
+func rewriteValue386_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVLconst [val])
@@ -13836,7 +13885,7 @@
return true
}
}
-func rewriteValue386_OpConst32F(v *Value) bool {
+func rewriteValue386_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVSSconst [val])
@@ -13847,7 +13896,7 @@
return true
}
}
-func rewriteValue386_OpConst64F(v *Value) bool {
+func rewriteValue386_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVSDconst [val])
@@ -13858,7 +13907,7 @@
return true
}
}
-func rewriteValue386_OpConst8(v *Value) bool {
+func rewriteValue386_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVLconst [val])
@@ -13869,7 +13918,7 @@
return true
}
}
-func rewriteValue386_OpConstBool(v *Value) bool {
+func rewriteValue386_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVLconst [b])
@@ -13880,7 +13929,7 @@
return true
}
}
-func rewriteValue386_OpConstNil(v *Value) bool {
+func rewriteValue386_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVLconst [0])
@@ -13890,7 +13939,7 @@
return true
}
}
-func rewriteValue386_OpConvert(v *Value) bool {
+func rewriteValue386_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVLconvert <t> x mem)
@@ -13905,7 +13954,7 @@
return true
}
}
-func rewriteValue386_OpCvt32Fto32(v *Value) bool {
+func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CVTTSS2SL x)
@@ -13916,7 +13965,7 @@
return true
}
}
-func rewriteValue386_OpCvt32Fto64F(v *Value) bool {
+func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (CVTSS2SD x)
@@ -13927,7 +13976,7 @@
return true
}
}
-func rewriteValue386_OpCvt32to32F(v *Value) bool {
+func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CVTSL2SS x)
@@ -13938,7 +13987,7 @@
return true
}
}
-func rewriteValue386_OpCvt32to64F(v *Value) bool {
+func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CVTSL2SD x)
@@ -13949,7 +13998,7 @@
return true
}
}
-func rewriteValue386_OpCvt64Fto32(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CVTTSD2SL x)
@@ -13960,7 +14009,7 @@
return true
}
}
-func rewriteValue386_OpCvt64Fto32F(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (CVTSD2SS x)
@@ -13971,7 +14020,7 @@
return true
}
}
-func rewriteValue386_OpDiv16(v *Value) bool {
+func rewriteValue386_OpDiv16_0(v *Value) bool {
// match: (Div16 x y)
// cond:
// result: (DIVW x y)
@@ -13984,7 +14033,7 @@
return true
}
}
-func rewriteValue386_OpDiv16u(v *Value) bool {
+func rewriteValue386_OpDiv16u_0(v *Value) bool {
// match: (Div16u x y)
// cond:
// result: (DIVWU x y)
@@ -13997,7 +14046,7 @@
return true
}
}
-func rewriteValue386_OpDiv32(v *Value) bool {
+func rewriteValue386_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVL x y)
@@ -14010,7 +14059,7 @@
return true
}
}
-func rewriteValue386_OpDiv32F(v *Value) bool {
+func rewriteValue386_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVSS x y)
@@ -14023,7 +14072,7 @@
return true
}
}
-func rewriteValue386_OpDiv32u(v *Value) bool {
+func rewriteValue386_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (DIVLU x y)
@@ -14036,7 +14085,7 @@
return true
}
}
-func rewriteValue386_OpDiv64F(v *Value) bool {
+func rewriteValue386_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVSD x y)
@@ -14049,7 +14098,7 @@
return true
}
}
-func rewriteValue386_OpDiv8(v *Value) bool {
+func rewriteValue386_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14070,7 +14119,7 @@
return true
}
}
-func rewriteValue386_OpDiv8u(v *Value) bool {
+func rewriteValue386_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14091,7 +14140,7 @@
return true
}
}
-func rewriteValue386_OpEq16(v *Value) bool {
+func rewriteValue386_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x y)
@@ -14108,7 +14157,7 @@
return true
}
}
-func rewriteValue386_OpEq32(v *Value) bool {
+func rewriteValue386_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
@@ -14125,7 +14174,7 @@
return true
}
}
-func rewriteValue386_OpEq32F(v *Value) bool {
+func rewriteValue386_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -14142,7 +14191,7 @@
return true
}
}
-func rewriteValue386_OpEq64F(v *Value) bool {
+func rewriteValue386_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -14159,7 +14208,7 @@
return true
}
}
-func rewriteValue386_OpEq8(v *Value) bool {
+func rewriteValue386_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x y)
@@ -14176,7 +14225,7 @@
return true
}
}
-func rewriteValue386_OpEqB(v *Value) bool {
+func rewriteValue386_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqB x y)
@@ -14193,7 +14242,7 @@
return true
}
}
-func rewriteValue386_OpEqPtr(v *Value) bool {
+func rewriteValue386_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
@@ -14210,7 +14259,7 @@
return true
}
}
-func rewriteValue386_OpGeq16(v *Value) bool {
+func rewriteValue386_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16 x y)
@@ -14227,7 +14276,7 @@
return true
}
}
-func rewriteValue386_OpGeq16U(v *Value) bool {
+func rewriteValue386_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16U x y)
@@ -14244,7 +14293,7 @@
return true
}
}
-func rewriteValue386_OpGeq32(v *Value) bool {
+func rewriteValue386_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
@@ -14261,7 +14310,7 @@
return true
}
}
-func rewriteValue386_OpGeq32F(v *Value) bool {
+func rewriteValue386_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -14278,7 +14327,7 @@
return true
}
}
-func rewriteValue386_OpGeq32U(v *Value) bool {
+func rewriteValue386_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
@@ -14295,7 +14344,7 @@
return true
}
}
-func rewriteValue386_OpGeq64F(v *Value) bool {
+func rewriteValue386_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -14312,7 +14361,7 @@
return true
}
}
-func rewriteValue386_OpGeq8(v *Value) bool {
+func rewriteValue386_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8 x y)
@@ -14329,7 +14378,7 @@
return true
}
}
-func rewriteValue386_OpGeq8U(v *Value) bool {
+func rewriteValue386_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8U x y)
@@ -14346,7 +14395,7 @@
return true
}
}
-func rewriteValue386_OpGetClosurePtr(v *Value) bool {
+func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -14355,7 +14404,7 @@
return true
}
}
-func rewriteValue386_OpGetG(v *Value) bool {
+func rewriteValue386_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
@@ -14366,7 +14415,7 @@
return true
}
}
-func rewriteValue386_OpGreater16(v *Value) bool {
+func rewriteValue386_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16 x y)
@@ -14383,7 +14432,7 @@
return true
}
}
-func rewriteValue386_OpGreater16U(v *Value) bool {
+func rewriteValue386_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16U x y)
@@ -14400,7 +14449,7 @@
return true
}
}
-func rewriteValue386_OpGreater32(v *Value) bool {
+func rewriteValue386_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
@@ -14417,7 +14466,7 @@
return true
}
}
-func rewriteValue386_OpGreater32F(v *Value) bool {
+func rewriteValue386_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -14434,7 +14483,7 @@
return true
}
}
-func rewriteValue386_OpGreater32U(v *Value) bool {
+func rewriteValue386_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
@@ -14451,7 +14500,7 @@
return true
}
}
-func rewriteValue386_OpGreater64F(v *Value) bool {
+func rewriteValue386_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -14468,7 +14517,7 @@
return true
}
}
-func rewriteValue386_OpGreater8(v *Value) bool {
+func rewriteValue386_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8 x y)
@@ -14485,7 +14534,7 @@
return true
}
}
-func rewriteValue386_OpGreater8U(v *Value) bool {
+func rewriteValue386_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8U x y)
@@ -14502,7 +14551,7 @@
return true
}
}
-func rewriteValue386_OpHmul32(v *Value) bool {
+func rewriteValue386_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMULL x y)
@@ -14515,7 +14564,7 @@
return true
}
}
-func rewriteValue386_OpHmul32u(v *Value) bool {
+func rewriteValue386_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULLU x y)
@@ -14528,7 +14577,7 @@
return true
}
}
-func rewriteValue386_OpInterCall(v *Value) bool {
+func rewriteValue386_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -14543,7 +14592,7 @@
return true
}
}
-func rewriteValue386_OpIsInBounds(v *Value) bool {
+func rewriteValue386_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
@@ -14560,7 +14609,7 @@
return true
}
}
-func rewriteValue386_OpIsNonNil(v *Value) bool {
+func rewriteValue386_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil p)
@@ -14576,7 +14625,7 @@
return true
}
}
-func rewriteValue386_OpIsSliceInBounds(v *Value) bool {
+func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
@@ -14593,7 +14642,7 @@
return true
}
}
-func rewriteValue386_OpLeq16(v *Value) bool {
+func rewriteValue386_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16 x y)
@@ -14610,7 +14659,7 @@
return true
}
}
-func rewriteValue386_OpLeq16U(v *Value) bool {
+func rewriteValue386_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16U x y)
@@ -14627,7 +14676,7 @@
return true
}
}
-func rewriteValue386_OpLeq32(v *Value) bool {
+func rewriteValue386_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
@@ -14644,7 +14693,7 @@
return true
}
}
-func rewriteValue386_OpLeq32F(v *Value) bool {
+func rewriteValue386_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -14661,7 +14710,7 @@
return true
}
}
-func rewriteValue386_OpLeq32U(v *Value) bool {
+func rewriteValue386_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
@@ -14678,7 +14727,7 @@
return true
}
}
-func rewriteValue386_OpLeq64F(v *Value) bool {
+func rewriteValue386_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -14695,7 +14744,7 @@
return true
}
}
-func rewriteValue386_OpLeq8(v *Value) bool {
+func rewriteValue386_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8 x y)
@@ -14712,7 +14761,7 @@
return true
}
}
-func rewriteValue386_OpLeq8U(v *Value) bool {
+func rewriteValue386_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8U x y)
@@ -14729,7 +14778,7 @@
return true
}
}
-func rewriteValue386_OpLess16(v *Value) bool {
+func rewriteValue386_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16 x y)
@@ -14746,7 +14795,7 @@
return true
}
}
-func rewriteValue386_OpLess16U(v *Value) bool {
+func rewriteValue386_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16U x y)
@@ -14763,7 +14812,7 @@
return true
}
}
-func rewriteValue386_OpLess32(v *Value) bool {
+func rewriteValue386_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
@@ -14780,7 +14829,7 @@
return true
}
}
-func rewriteValue386_OpLess32F(v *Value) bool {
+func rewriteValue386_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -14797,7 +14846,7 @@
return true
}
}
-func rewriteValue386_OpLess32U(v *Value) bool {
+func rewriteValue386_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
@@ -14814,7 +14863,7 @@
return true
}
}
-func rewriteValue386_OpLess64F(v *Value) bool {
+func rewriteValue386_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -14831,7 +14880,7 @@
return true
}
}
-func rewriteValue386_OpLess8(v *Value) bool {
+func rewriteValue386_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8 x y)
@@ -14848,7 +14897,7 @@
return true
}
}
-func rewriteValue386_OpLess8U(v *Value) bool {
+func rewriteValue386_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8U x y)
@@ -14865,7 +14914,7 @@
return true
}
}
-func rewriteValue386_OpLoad(v *Value) bool {
+func rewriteValue386_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: (is32BitInt(t) || isPtr(t))
// result: (MOVLload ptr mem)
@@ -14943,7 +14992,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x16(v *Value) bool {
+func rewriteValue386_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x y)
@@ -14967,7 +15016,7 @@
return true
}
}
-func rewriteValue386_OpLsh16x32(v *Value) bool {
+func rewriteValue386_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
@@ -14991,7 +15040,7 @@
return true
}
}
-func rewriteValue386_OpLsh16x64(v *Value) bool {
+func rewriteValue386_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SHLLconst x [c])
@@ -15028,7 +15077,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x8(v *Value) bool {
+func rewriteValue386_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x y)
@@ -15052,7 +15101,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x16(v *Value) bool {
+func rewriteValue386_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x y)
@@ -15076,7 +15125,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x32(v *Value) bool {
+func rewriteValue386_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
@@ -15100,7 +15149,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x64(v *Value) bool {
+func rewriteValue386_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SHLLconst x [c])
@@ -15137,7 +15186,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x8(v *Value) bool {
+func rewriteValue386_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x y)
@@ -15161,7 +15210,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x16(v *Value) bool {
+func rewriteValue386_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x y)
@@ -15185,7 +15234,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x32(v *Value) bool {
+func rewriteValue386_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
@@ -15209,7 +15258,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x64(v *Value) bool {
+func rewriteValue386_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SHLLconst x [c])
@@ -15246,7 +15295,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x8(v *Value) bool {
+func rewriteValue386_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x y)
@@ -15270,7 +15319,7 @@
return true
}
}
-func rewriteValue386_OpMod16(v *Value) bool {
+func rewriteValue386_OpMod16_0(v *Value) bool {
// match: (Mod16 x y)
// cond:
// result: (MODW x y)
@@ -15283,7 +15332,7 @@
return true
}
}
-func rewriteValue386_OpMod16u(v *Value) bool {
+func rewriteValue386_OpMod16u_0(v *Value) bool {
// match: (Mod16u x y)
// cond:
// result: (MODWU x y)
@@ -15296,7 +15345,7 @@
return true
}
}
-func rewriteValue386_OpMod32(v *Value) bool {
+func rewriteValue386_OpMod32_0(v *Value) bool {
// match: (Mod32 x y)
// cond:
// result: (MODL x y)
@@ -15309,7 +15358,7 @@
return true
}
}
-func rewriteValue386_OpMod32u(v *Value) bool {
+func rewriteValue386_OpMod32u_0(v *Value) bool {
// match: (Mod32u x y)
// cond:
// result: (MODLU x y)
@@ -15322,7 +15371,7 @@
return true
}
}
-func rewriteValue386_OpMod8(v *Value) bool {
+func rewriteValue386_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15343,7 +15392,7 @@
return true
}
}
-func rewriteValue386_OpMod8u(v *Value) bool {
+func rewriteValue386_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15364,11 +15413,9 @@
return true
}
}
-func rewriteValue386_OpMove(v *Value) bool {
+func rewriteValue386_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
@@ -15612,6 +15659,15 @@
v.AddArg(v2)
return true
}
+ return false
+}
+func rewriteValue386_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [s] dst src mem)
// cond: s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice
// result: (DUFFCOPY [10*(128-s/4)] dst src mem)
@@ -15652,7 +15708,7 @@
}
return false
}
-func rewriteValue386_OpMul16(v *Value) bool {
+func rewriteValue386_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULL x y)
@@ -15665,7 +15721,7 @@
return true
}
}
-func rewriteValue386_OpMul32(v *Value) bool {
+func rewriteValue386_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULL x y)
@@ -15678,7 +15734,7 @@
return true
}
}
-func rewriteValue386_OpMul32F(v *Value) bool {
+func rewriteValue386_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULSS x y)
@@ -15691,7 +15747,7 @@
return true
}
}
-func rewriteValue386_OpMul32uhilo(v *Value) bool {
+func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULLQU x y)
@@ -15704,7 +15760,7 @@
return true
}
}
-func rewriteValue386_OpMul64F(v *Value) bool {
+func rewriteValue386_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULSD x y)
@@ -15717,7 +15773,7 @@
return true
}
}
-func rewriteValue386_OpMul8(v *Value) bool {
+func rewriteValue386_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULL x y)
@@ -15730,7 +15786,7 @@
return true
}
}
-func rewriteValue386_OpNeg16(v *Value) bool {
+func rewriteValue386_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGL x)
@@ -15741,7 +15797,7 @@
return true
}
}
-func rewriteValue386_OpNeg32(v *Value) bool {
+func rewriteValue386_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGL x)
@@ -15752,7 +15808,7 @@
return true
}
}
-func rewriteValue386_OpNeg32F(v *Value) bool {
+func rewriteValue386_OpNeg32F_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -15788,7 +15844,7 @@
}
return false
}
-func rewriteValue386_OpNeg64F(v *Value) bool {
+func rewriteValue386_OpNeg64F_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -15824,7 +15880,7 @@
}
return false
}
-func rewriteValue386_OpNeg8(v *Value) bool {
+func rewriteValue386_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGL x)
@@ -15835,7 +15891,7 @@
return true
}
}
-func rewriteValue386_OpNeq16(v *Value) bool {
+func rewriteValue386_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x y)
@@ -15852,7 +15908,7 @@
return true
}
}
-func rewriteValue386_OpNeq32(v *Value) bool {
+func rewriteValue386_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
@@ -15869,7 +15925,7 @@
return true
}
}
-func rewriteValue386_OpNeq32F(v *Value) bool {
+func rewriteValue386_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -15886,7 +15942,7 @@
return true
}
}
-func rewriteValue386_OpNeq64F(v *Value) bool {
+func rewriteValue386_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -15903,7 +15959,7 @@
return true
}
}
-func rewriteValue386_OpNeq8(v *Value) bool {
+func rewriteValue386_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x y)
@@ -15920,7 +15976,7 @@
return true
}
}
-func rewriteValue386_OpNeqB(v *Value) bool {
+func rewriteValue386_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqB x y)
@@ -15937,7 +15993,7 @@
return true
}
}
-func rewriteValue386_OpNeqPtr(v *Value) bool {
+func rewriteValue386_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
@@ -15954,7 +16010,7 @@
return true
}
}
-func rewriteValue386_OpNilCheck(v *Value) bool {
+func rewriteValue386_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -15967,7 +16023,7 @@
return true
}
}
-func rewriteValue386_OpNot(v *Value) bool {
+func rewriteValue386_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORLconst [1] x)
@@ -15979,7 +16035,7 @@
return true
}
}
-func rewriteValue386_OpOffPtr(v *Value) bool {
+func rewriteValue386_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr)
// cond:
// result: (ADDLconst [off] ptr)
@@ -15992,7 +16048,7 @@
return true
}
}
-func rewriteValue386_OpOr16(v *Value) bool {
+func rewriteValue386_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORL x y)
@@ -16005,7 +16061,7 @@
return true
}
}
-func rewriteValue386_OpOr32(v *Value) bool {
+func rewriteValue386_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORL x y)
@@ -16018,7 +16074,7 @@
return true
}
}
-func rewriteValue386_OpOr8(v *Value) bool {
+func rewriteValue386_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORL x y)
@@ -16031,7 +16087,7 @@
return true
}
}
-func rewriteValue386_OpOrB(v *Value) bool {
+func rewriteValue386_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORL x y)
@@ -16044,7 +16100,7 @@
return true
}
}
-func rewriteValue386_OpRound32F(v *Value) bool {
+func rewriteValue386_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
@@ -16056,7 +16112,7 @@
return true
}
}
-func rewriteValue386_OpRound64F(v *Value) bool {
+func rewriteValue386_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
@@ -16068,7 +16124,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux16(v *Value) bool {
+func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x y)
@@ -16092,7 +16148,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux32(v *Value) bool {
+func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x y)
@@ -16116,7 +16172,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux64(v *Value) bool {
+func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
// match: (Rsh16Ux64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SHRWconst x [c])
@@ -16153,7 +16209,7 @@
}
return false
}
-func rewriteValue386_OpRsh16Ux8(v *Value) bool {
+func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x y)
@@ -16177,7 +16233,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x16(v *Value) bool {
+func rewriteValue386_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x y)
@@ -16204,7 +16260,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x32(v *Value) bool {
+func rewriteValue386_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x y)
@@ -16231,7 +16287,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x64(v *Value) bool {
+func rewriteValue386_OpRsh16x64_0(v *Value) bool {
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SARWconst x [c])
@@ -16270,7 +16326,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x8(v *Value) bool {
+func rewriteValue386_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x y)
@@ -16297,7 +16353,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux16(v *Value) bool {
+func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x y)
@@ -16321,7 +16377,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux32(v *Value) bool {
+func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
@@ -16345,7 +16401,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux64(v *Value) bool {
+func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SHRLconst x [c])
@@ -16382,7 +16438,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux8(v *Value) bool {
+func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x y)
@@ -16406,7 +16462,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x16(v *Value) bool {
+func rewriteValue386_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x y)
@@ -16433,7 +16489,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x32(v *Value) bool {
+func rewriteValue386_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
@@ -16460,7 +16516,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x64(v *Value) bool {
+func rewriteValue386_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SARLconst x [c])
@@ -16499,7 +16555,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x8(v *Value) bool {
+func rewriteValue386_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x y)
@@ -16526,7 +16582,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux16(v *Value) bool {
+func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x y)
@@ -16550,7 +16606,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux32(v *Value) bool {
+func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x y)
@@ -16574,7 +16630,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux64(v *Value) bool {
+func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
// match: (Rsh8Ux64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SHRBconst x [c])
@@ -16611,7 +16667,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux8(v *Value) bool {
+func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x y)
@@ -16635,7 +16691,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x16(v *Value) bool {
+func rewriteValue386_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x y)
@@ -16662,7 +16718,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x32(v *Value) bool {
+func rewriteValue386_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x y)
@@ -16689,7 +16745,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x64(v *Value) bool {
+func rewriteValue386_OpRsh8x64_0(v *Value) bool {
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SARBconst x [c])
@@ -16728,7 +16784,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x8(v *Value) bool {
+func rewriteValue386_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x y)
@@ -16755,7 +16811,7 @@
return true
}
}
-func rewriteValue386_OpSignExt16to32(v *Value) bool {
+func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVWLSX x)
@@ -16766,7 +16822,7 @@
return true
}
}
-func rewriteValue386_OpSignExt8to16(v *Value) bool {
+func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBLSX x)
@@ -16777,7 +16833,7 @@
return true
}
}
-func rewriteValue386_OpSignExt8to32(v *Value) bool {
+func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBLSX x)
@@ -16788,7 +16844,7 @@
return true
}
}
-func rewriteValue386_OpSignmask(v *Value) bool {
+func rewriteValue386_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SARLconst x [31])
@@ -16800,7 +16856,7 @@
return true
}
}
-func rewriteValue386_OpSlicemask(v *Value) bool {
+func rewriteValue386_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -16817,7 +16873,7 @@
return true
}
}
-func rewriteValue386_OpSqrt(v *Value) bool {
+func rewriteValue386_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTSD x)
@@ -16828,7 +16884,7 @@
return true
}
}
-func rewriteValue386_OpStaticCall(v *Value) bool {
+func rewriteValue386_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -16843,7 +16899,7 @@
return true
}
}
-func rewriteValue386_OpStore(v *Value) bool {
+func rewriteValue386_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
@@ -16931,7 +16987,7 @@
}
return false
}
-func rewriteValue386_OpSub16(v *Value) bool {
+func rewriteValue386_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBL x y)
@@ -16944,7 +17000,7 @@
return true
}
}
-func rewriteValue386_OpSub32(v *Value) bool {
+func rewriteValue386_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBL x y)
@@ -16957,7 +17013,7 @@
return true
}
}
-func rewriteValue386_OpSub32F(v *Value) bool {
+func rewriteValue386_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBSS x y)
@@ -16970,7 +17026,7 @@
return true
}
}
-func rewriteValue386_OpSub32carry(v *Value) bool {
+func rewriteValue386_OpSub32carry_0(v *Value) bool {
// match: (Sub32carry x y)
// cond:
// result: (SUBLcarry x y)
@@ -16983,7 +17039,7 @@
return true
}
}
-func rewriteValue386_OpSub32withcarry(v *Value) bool {
+func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
// match: (Sub32withcarry x y c)
// cond:
// result: (SBBL x y c)
@@ -16998,7 +17054,7 @@
return true
}
}
-func rewriteValue386_OpSub64F(v *Value) bool {
+func rewriteValue386_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBSD x y)
@@ -17011,7 +17067,7 @@
return true
}
}
-func rewriteValue386_OpSub8(v *Value) bool {
+func rewriteValue386_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBL x y)
@@ -17024,7 +17080,7 @@
return true
}
}
-func rewriteValue386_OpSubPtr(v *Value) bool {
+func rewriteValue386_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUBL x y)
@@ -17037,7 +17093,7 @@
return true
}
}
-func rewriteValue386_OpTrunc16to8(v *Value) bool {
+func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -17049,7 +17105,7 @@
return true
}
}
-func rewriteValue386_OpTrunc32to16(v *Value) bool {
+func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -17061,7 +17117,7 @@
return true
}
}
-func rewriteValue386_OpTrunc32to8(v *Value) bool {
+func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -17073,7 +17129,7 @@
return true
}
}
-func rewriteValue386_OpXor16(v *Value) bool {
+func rewriteValue386_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORL x y)
@@ -17086,7 +17142,7 @@
return true
}
}
-func rewriteValue386_OpXor32(v *Value) bool {
+func rewriteValue386_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORL x y)
@@ -17099,7 +17155,7 @@
return true
}
}
-func rewriteValue386_OpXor8(v *Value) bool {
+func rewriteValue386_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORL x y)
@@ -17112,11 +17168,9 @@
return true
}
}
-func rewriteValue386_OpZero(v *Value) bool {
+func rewriteValue386_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
@@ -17295,6 +17349,15 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValue386_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [12] destptr mem)
// cond:
// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)))
@@ -17387,7 +17450,7 @@
}
return false
}
-func rewriteValue386_OpZeroExt16to32(v *Value) bool {
+func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVWLZX x)
@@ -17398,7 +17461,7 @@
return true
}
}
-func rewriteValue386_OpZeroExt8to16(v *Value) bool {
+func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBLZX x)
@@ -17409,7 +17472,7 @@
return true
}
}
-func rewriteValue386_OpZeroExt8to32(v *Value) bool {
+func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBLZX x)
@@ -17420,7 +17483,7 @@
return true
}
}
-func rewriteValue386_OpZeromask(v *Value) bool {
+func rewriteValue386_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zeromask <t> x)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 9f9fe3b..4bd2a79 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -14,849 +14,849 @@
func rewriteValueAMD64(v *Value) bool {
switch v.Op {
case OpAMD64ADDL:
- return rewriteValueAMD64_OpAMD64ADDL(v)
+ return rewriteValueAMD64_OpAMD64ADDL_0(v) || rewriteValueAMD64_OpAMD64ADDL_10(v)
case OpAMD64ADDLconst:
- return rewriteValueAMD64_OpAMD64ADDLconst(v)
+ return rewriteValueAMD64_OpAMD64ADDLconst_0(v)
case OpAMD64ADDQ:
- return rewriteValueAMD64_OpAMD64ADDQ(v)
+ return rewriteValueAMD64_OpAMD64ADDQ_0(v) || rewriteValueAMD64_OpAMD64ADDQ_10(v) || rewriteValueAMD64_OpAMD64ADDQ_20(v)
case OpAMD64ADDQconst:
- return rewriteValueAMD64_OpAMD64ADDQconst(v)
+ return rewriteValueAMD64_OpAMD64ADDQconst_0(v)
case OpAMD64ADDSD:
- return rewriteValueAMD64_OpAMD64ADDSD(v)
+ return rewriteValueAMD64_OpAMD64ADDSD_0(v)
case OpAMD64ADDSS:
- return rewriteValueAMD64_OpAMD64ADDSS(v)
+ return rewriteValueAMD64_OpAMD64ADDSS_0(v)
case OpAMD64ANDL:
- return rewriteValueAMD64_OpAMD64ANDL(v)
+ return rewriteValueAMD64_OpAMD64ANDL_0(v)
case OpAMD64ANDLconst:
- return rewriteValueAMD64_OpAMD64ANDLconst(v)
+ return rewriteValueAMD64_OpAMD64ANDLconst_0(v)
case OpAMD64ANDQ:
- return rewriteValueAMD64_OpAMD64ANDQ(v)
+ return rewriteValueAMD64_OpAMD64ANDQ_0(v)
case OpAMD64ANDQconst:
- return rewriteValueAMD64_OpAMD64ANDQconst(v)
+ return rewriteValueAMD64_OpAMD64ANDQconst_0(v)
case OpAMD64BSFQ:
- return rewriteValueAMD64_OpAMD64BSFQ(v)
+ return rewriteValueAMD64_OpAMD64BSFQ_0(v)
case OpAMD64BTQconst:
- return rewriteValueAMD64_OpAMD64BTQconst(v)
+ return rewriteValueAMD64_OpAMD64BTQconst_0(v)
case OpAMD64CMOVQEQ:
- return rewriteValueAMD64_OpAMD64CMOVQEQ(v)
+ return rewriteValueAMD64_OpAMD64CMOVQEQ_0(v)
case OpAMD64CMPB:
- return rewriteValueAMD64_OpAMD64CMPB(v)
+ return rewriteValueAMD64_OpAMD64CMPB_0(v)
case OpAMD64CMPBconst:
- return rewriteValueAMD64_OpAMD64CMPBconst(v)
+ return rewriteValueAMD64_OpAMD64CMPBconst_0(v)
case OpAMD64CMPL:
- return rewriteValueAMD64_OpAMD64CMPL(v)
+ return rewriteValueAMD64_OpAMD64CMPL_0(v)
case OpAMD64CMPLconst:
- return rewriteValueAMD64_OpAMD64CMPLconst(v)
+ return rewriteValueAMD64_OpAMD64CMPLconst_0(v)
case OpAMD64CMPQ:
- return rewriteValueAMD64_OpAMD64CMPQ(v)
+ return rewriteValueAMD64_OpAMD64CMPQ_0(v)
case OpAMD64CMPQconst:
- return rewriteValueAMD64_OpAMD64CMPQconst(v)
+ return rewriteValueAMD64_OpAMD64CMPQconst_0(v) || rewriteValueAMD64_OpAMD64CMPQconst_10(v)
case OpAMD64CMPW:
- return rewriteValueAMD64_OpAMD64CMPW(v)
+ return rewriteValueAMD64_OpAMD64CMPW_0(v)
case OpAMD64CMPWconst:
- return rewriteValueAMD64_OpAMD64CMPWconst(v)
+ return rewriteValueAMD64_OpAMD64CMPWconst_0(v)
case OpAMD64CMPXCHGLlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v)
case OpAMD64CMPXCHGQlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v)
case OpAMD64LEAL:
- return rewriteValueAMD64_OpAMD64LEAL(v)
+ return rewriteValueAMD64_OpAMD64LEAL_0(v)
case OpAMD64LEAQ:
- return rewriteValueAMD64_OpAMD64LEAQ(v)
+ return rewriteValueAMD64_OpAMD64LEAQ_0(v)
case OpAMD64LEAQ1:
- return rewriteValueAMD64_OpAMD64LEAQ1(v)
+ return rewriteValueAMD64_OpAMD64LEAQ1_0(v)
case OpAMD64LEAQ2:
- return rewriteValueAMD64_OpAMD64LEAQ2(v)
+ return rewriteValueAMD64_OpAMD64LEAQ2_0(v)
case OpAMD64LEAQ4:
- return rewriteValueAMD64_OpAMD64LEAQ4(v)
+ return rewriteValueAMD64_OpAMD64LEAQ4_0(v)
case OpAMD64LEAQ8:
- return rewriteValueAMD64_OpAMD64LEAQ8(v)
+ return rewriteValueAMD64_OpAMD64LEAQ8_0(v)
case OpAMD64MOVBQSX:
- return rewriteValueAMD64_OpAMD64MOVBQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSX_0(v)
case OpAMD64MOVBQSXload:
- return rewriteValueAMD64_OpAMD64MOVBQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSXload_0(v)
case OpAMD64MOVBQZX:
- return rewriteValueAMD64_OpAMD64MOVBQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVBQZX_0(v)
case OpAMD64MOVBload:
- return rewriteValueAMD64_OpAMD64MOVBload(v)
+ return rewriteValueAMD64_OpAMD64MOVBload_0(v)
case OpAMD64MOVBloadidx1:
- return rewriteValueAMD64_OpAMD64MOVBloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v)
case OpAMD64MOVBstore:
- return rewriteValueAMD64_OpAMD64MOVBstore(v)
+ return rewriteValueAMD64_OpAMD64MOVBstore_0(v) || rewriteValueAMD64_OpAMD64MOVBstore_10(v)
case OpAMD64MOVBstoreconst:
- return rewriteValueAMD64_OpAMD64MOVBstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v)
case OpAMD64MOVBstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v)
case OpAMD64MOVBstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v)
case OpAMD64MOVLQSX:
- return rewriteValueAMD64_OpAMD64MOVLQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSX_0(v)
case OpAMD64MOVLQSXload:
- return rewriteValueAMD64_OpAMD64MOVLQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSXload_0(v)
case OpAMD64MOVLQZX:
- return rewriteValueAMD64_OpAMD64MOVLQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVLQZX_0(v)
case OpAMD64MOVLatomicload:
- return rewriteValueAMD64_OpAMD64MOVLatomicload(v)
+ return rewriteValueAMD64_OpAMD64MOVLatomicload_0(v)
case OpAMD64MOVLload:
- return rewriteValueAMD64_OpAMD64MOVLload(v)
+ return rewriteValueAMD64_OpAMD64MOVLload_0(v)
case OpAMD64MOVLloadidx1:
- return rewriteValueAMD64_OpAMD64MOVLloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v)
case OpAMD64MOVLloadidx4:
- return rewriteValueAMD64_OpAMD64MOVLloadidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v)
case OpAMD64MOVLstore:
- return rewriteValueAMD64_OpAMD64MOVLstore(v)
+ return rewriteValueAMD64_OpAMD64MOVLstore_0(v) || rewriteValueAMD64_OpAMD64MOVLstore_10(v)
case OpAMD64MOVLstoreconst:
- return rewriteValueAMD64_OpAMD64MOVLstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v)
case OpAMD64MOVLstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v)
case OpAMD64MOVLstoreconstidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v)
case OpAMD64MOVLstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v)
case OpAMD64MOVLstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v)
case OpAMD64MOVOload:
- return rewriteValueAMD64_OpAMD64MOVOload(v)
+ return rewriteValueAMD64_OpAMD64MOVOload_0(v)
case OpAMD64MOVOstore:
- return rewriteValueAMD64_OpAMD64MOVOstore(v)
+ return rewriteValueAMD64_OpAMD64MOVOstore_0(v)
case OpAMD64MOVQatomicload:
- return rewriteValueAMD64_OpAMD64MOVQatomicload(v)
+ return rewriteValueAMD64_OpAMD64MOVQatomicload_0(v)
case OpAMD64MOVQload:
- return rewriteValueAMD64_OpAMD64MOVQload(v)
+ return rewriteValueAMD64_OpAMD64MOVQload_0(v)
case OpAMD64MOVQloadidx1:
- return rewriteValueAMD64_OpAMD64MOVQloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v)
case OpAMD64MOVQloadidx8:
- return rewriteValueAMD64_OpAMD64MOVQloadidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v)
case OpAMD64MOVQstore:
- return rewriteValueAMD64_OpAMD64MOVQstore(v)
+ return rewriteValueAMD64_OpAMD64MOVQstore_0(v)
case OpAMD64MOVQstoreconst:
- return rewriteValueAMD64_OpAMD64MOVQstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v)
case OpAMD64MOVQstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v)
case OpAMD64MOVQstoreconstidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v)
case OpAMD64MOVQstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v)
case OpAMD64MOVQstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v)
case OpAMD64MOVSDload:
- return rewriteValueAMD64_OpAMD64MOVSDload(v)
+ return rewriteValueAMD64_OpAMD64MOVSDload_0(v)
case OpAMD64MOVSDloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v)
case OpAMD64MOVSDloadidx8:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v)
case OpAMD64MOVSDstore:
- return rewriteValueAMD64_OpAMD64MOVSDstore(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstore_0(v)
case OpAMD64MOVSDstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v)
case OpAMD64MOVSDstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v)
case OpAMD64MOVSSload:
- return rewriteValueAMD64_OpAMD64MOVSSload(v)
+ return rewriteValueAMD64_OpAMD64MOVSSload_0(v)
case OpAMD64MOVSSloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v)
case OpAMD64MOVSSloadidx4:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v)
case OpAMD64MOVSSstore:
- return rewriteValueAMD64_OpAMD64MOVSSstore(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstore_0(v)
case OpAMD64MOVSSstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v)
case OpAMD64MOVSSstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v)
case OpAMD64MOVWQSX:
- return rewriteValueAMD64_OpAMD64MOVWQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSX_0(v)
case OpAMD64MOVWQSXload:
- return rewriteValueAMD64_OpAMD64MOVWQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSXload_0(v)
case OpAMD64MOVWQZX:
- return rewriteValueAMD64_OpAMD64MOVWQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVWQZX_0(v)
case OpAMD64MOVWload:
- return rewriteValueAMD64_OpAMD64MOVWload(v)
+ return rewriteValueAMD64_OpAMD64MOVWload_0(v)
case OpAMD64MOVWloadidx1:
- return rewriteValueAMD64_OpAMD64MOVWloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v)
case OpAMD64MOVWloadidx2:
- return rewriteValueAMD64_OpAMD64MOVWloadidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v)
case OpAMD64MOVWstore:
- return rewriteValueAMD64_OpAMD64MOVWstore(v)
+ return rewriteValueAMD64_OpAMD64MOVWstore_0(v) || rewriteValueAMD64_OpAMD64MOVWstore_10(v)
case OpAMD64MOVWstoreconst:
- return rewriteValueAMD64_OpAMD64MOVWstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v)
case OpAMD64MOVWstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v)
case OpAMD64MOVWstoreconstidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v)
case OpAMD64MOVWstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v)
case OpAMD64MOVWstoreidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v)
case OpAMD64MULL:
- return rewriteValueAMD64_OpAMD64MULL(v)
+ return rewriteValueAMD64_OpAMD64MULL_0(v)
case OpAMD64MULLconst:
- return rewriteValueAMD64_OpAMD64MULLconst(v)
+ return rewriteValueAMD64_OpAMD64MULLconst_0(v)
case OpAMD64MULQ:
- return rewriteValueAMD64_OpAMD64MULQ(v)
+ return rewriteValueAMD64_OpAMD64MULQ_0(v)
case OpAMD64MULQconst:
- return rewriteValueAMD64_OpAMD64MULQconst(v)
+ return rewriteValueAMD64_OpAMD64MULQconst_0(v) || rewriteValueAMD64_OpAMD64MULQconst_10(v) || rewriteValueAMD64_OpAMD64MULQconst_20(v)
case OpAMD64MULSD:
- return rewriteValueAMD64_OpAMD64MULSD(v)
+ return rewriteValueAMD64_OpAMD64MULSD_0(v)
case OpAMD64MULSS:
- return rewriteValueAMD64_OpAMD64MULSS(v)
+ return rewriteValueAMD64_OpAMD64MULSS_0(v)
case OpAMD64NEGL:
- return rewriteValueAMD64_OpAMD64NEGL(v)
+ return rewriteValueAMD64_OpAMD64NEGL_0(v)
case OpAMD64NEGQ:
- return rewriteValueAMD64_OpAMD64NEGQ(v)
+ return rewriteValueAMD64_OpAMD64NEGQ_0(v)
case OpAMD64NOTL:
- return rewriteValueAMD64_OpAMD64NOTL(v)
+ return rewriteValueAMD64_OpAMD64NOTL_0(v)
case OpAMD64NOTQ:
- return rewriteValueAMD64_OpAMD64NOTQ(v)
+ return rewriteValueAMD64_OpAMD64NOTQ_0(v)
case OpAMD64ORL:
- return rewriteValueAMD64_OpAMD64ORL(v)
+ return rewriteValueAMD64_OpAMD64ORL_0(v) || rewriteValueAMD64_OpAMD64ORL_10(v) || rewriteValueAMD64_OpAMD64ORL_20(v) || rewriteValueAMD64_OpAMD64ORL_30(v) || rewriteValueAMD64_OpAMD64ORL_40(v) || rewriteValueAMD64_OpAMD64ORL_50(v) || rewriteValueAMD64_OpAMD64ORL_60(v) || rewriteValueAMD64_OpAMD64ORL_70(v) || rewriteValueAMD64_OpAMD64ORL_80(v) || rewriteValueAMD64_OpAMD64ORL_90(v) || rewriteValueAMD64_OpAMD64ORL_100(v) || rewriteValueAMD64_OpAMD64ORL_110(v) || rewriteValueAMD64_OpAMD64ORL_120(v) || rewriteValueAMD64_OpAMD64ORL_130(v)
case OpAMD64ORLconst:
- return rewriteValueAMD64_OpAMD64ORLconst(v)
+ return rewriteValueAMD64_OpAMD64ORLconst_0(v)
case OpAMD64ORQ:
- return rewriteValueAMD64_OpAMD64ORQ(v)
+ return rewriteValueAMD64_OpAMD64ORQ_0(v) || rewriteValueAMD64_OpAMD64ORQ_10(v) || rewriteValueAMD64_OpAMD64ORQ_20(v) || rewriteValueAMD64_OpAMD64ORQ_30(v) || rewriteValueAMD64_OpAMD64ORQ_40(v) || rewriteValueAMD64_OpAMD64ORQ_50(v) || rewriteValueAMD64_OpAMD64ORQ_60(v) || rewriteValueAMD64_OpAMD64ORQ_70(v) || rewriteValueAMD64_OpAMD64ORQ_80(v) || rewriteValueAMD64_OpAMD64ORQ_90(v) || rewriteValueAMD64_OpAMD64ORQ_100(v) || rewriteValueAMD64_OpAMD64ORQ_110(v) || rewriteValueAMD64_OpAMD64ORQ_120(v) || rewriteValueAMD64_OpAMD64ORQ_130(v) || rewriteValueAMD64_OpAMD64ORQ_140(v) || rewriteValueAMD64_OpAMD64ORQ_150(v) || rewriteValueAMD64_OpAMD64ORQ_160(v)
case OpAMD64ORQconst:
- return rewriteValueAMD64_OpAMD64ORQconst(v)
+ return rewriteValueAMD64_OpAMD64ORQconst_0(v)
case OpAMD64ROLB:
- return rewriteValueAMD64_OpAMD64ROLB(v)
+ return rewriteValueAMD64_OpAMD64ROLB_0(v)
case OpAMD64ROLBconst:
- return rewriteValueAMD64_OpAMD64ROLBconst(v)
+ return rewriteValueAMD64_OpAMD64ROLBconst_0(v)
case OpAMD64ROLL:
- return rewriteValueAMD64_OpAMD64ROLL(v)
+ return rewriteValueAMD64_OpAMD64ROLL_0(v)
case OpAMD64ROLLconst:
- return rewriteValueAMD64_OpAMD64ROLLconst(v)
+ return rewriteValueAMD64_OpAMD64ROLLconst_0(v)
case OpAMD64ROLQ:
- return rewriteValueAMD64_OpAMD64ROLQ(v)
+ return rewriteValueAMD64_OpAMD64ROLQ_0(v)
case OpAMD64ROLQconst:
- return rewriteValueAMD64_OpAMD64ROLQconst(v)
+ return rewriteValueAMD64_OpAMD64ROLQconst_0(v)
case OpAMD64ROLW:
- return rewriteValueAMD64_OpAMD64ROLW(v)
+ return rewriteValueAMD64_OpAMD64ROLW_0(v)
case OpAMD64ROLWconst:
- return rewriteValueAMD64_OpAMD64ROLWconst(v)
+ return rewriteValueAMD64_OpAMD64ROLWconst_0(v)
case OpAMD64RORB:
- return rewriteValueAMD64_OpAMD64RORB(v)
+ return rewriteValueAMD64_OpAMD64RORB_0(v)
case OpAMD64RORL:
- return rewriteValueAMD64_OpAMD64RORL(v)
+ return rewriteValueAMD64_OpAMD64RORL_0(v)
case OpAMD64RORQ:
- return rewriteValueAMD64_OpAMD64RORQ(v)
+ return rewriteValueAMD64_OpAMD64RORQ_0(v)
case OpAMD64RORW:
- return rewriteValueAMD64_OpAMD64RORW(v)
+ return rewriteValueAMD64_OpAMD64RORW_0(v)
case OpAMD64SARB:
- return rewriteValueAMD64_OpAMD64SARB(v)
+ return rewriteValueAMD64_OpAMD64SARB_0(v)
case OpAMD64SARBconst:
- return rewriteValueAMD64_OpAMD64SARBconst(v)
+ return rewriteValueAMD64_OpAMD64SARBconst_0(v)
case OpAMD64SARL:
- return rewriteValueAMD64_OpAMD64SARL(v)
+ return rewriteValueAMD64_OpAMD64SARL_0(v)
case OpAMD64SARLconst:
- return rewriteValueAMD64_OpAMD64SARLconst(v)
+ return rewriteValueAMD64_OpAMD64SARLconst_0(v)
case OpAMD64SARQ:
- return rewriteValueAMD64_OpAMD64SARQ(v)
+ return rewriteValueAMD64_OpAMD64SARQ_0(v)
case OpAMD64SARQconst:
- return rewriteValueAMD64_OpAMD64SARQconst(v)
+ return rewriteValueAMD64_OpAMD64SARQconst_0(v)
case OpAMD64SARW:
- return rewriteValueAMD64_OpAMD64SARW(v)
+ return rewriteValueAMD64_OpAMD64SARW_0(v)
case OpAMD64SARWconst:
- return rewriteValueAMD64_OpAMD64SARWconst(v)
+ return rewriteValueAMD64_OpAMD64SARWconst_0(v)
case OpAMD64SBBLcarrymask:
- return rewriteValueAMD64_OpAMD64SBBLcarrymask(v)
+ return rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v)
case OpAMD64SBBQcarrymask:
- return rewriteValueAMD64_OpAMD64SBBQcarrymask(v)
+ return rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v)
case OpAMD64SETA:
- return rewriteValueAMD64_OpAMD64SETA(v)
+ return rewriteValueAMD64_OpAMD64SETA_0(v)
case OpAMD64SETAE:
- return rewriteValueAMD64_OpAMD64SETAE(v)
+ return rewriteValueAMD64_OpAMD64SETAE_0(v)
case OpAMD64SETB:
- return rewriteValueAMD64_OpAMD64SETB(v)
+ return rewriteValueAMD64_OpAMD64SETB_0(v)
case OpAMD64SETBE:
- return rewriteValueAMD64_OpAMD64SETBE(v)
+ return rewriteValueAMD64_OpAMD64SETBE_0(v)
case OpAMD64SETEQ:
- return rewriteValueAMD64_OpAMD64SETEQ(v)
+ return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v)
case OpAMD64SETG:
- return rewriteValueAMD64_OpAMD64SETG(v)
+ return rewriteValueAMD64_OpAMD64SETG_0(v)
case OpAMD64SETGE:
- return rewriteValueAMD64_OpAMD64SETGE(v)
+ return rewriteValueAMD64_OpAMD64SETGE_0(v)
case OpAMD64SETL:
- return rewriteValueAMD64_OpAMD64SETL(v)
+ return rewriteValueAMD64_OpAMD64SETL_0(v)
case OpAMD64SETLE:
- return rewriteValueAMD64_OpAMD64SETLE(v)
+ return rewriteValueAMD64_OpAMD64SETLE_0(v)
case OpAMD64SETNE:
- return rewriteValueAMD64_OpAMD64SETNE(v)
+ return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v)
case OpAMD64SHLL:
- return rewriteValueAMD64_OpAMD64SHLL(v)
+ return rewriteValueAMD64_OpAMD64SHLL_0(v)
case OpAMD64SHLLconst:
- return rewriteValueAMD64_OpAMD64SHLLconst(v)
+ return rewriteValueAMD64_OpAMD64SHLLconst_0(v)
case OpAMD64SHLQ:
- return rewriteValueAMD64_OpAMD64SHLQ(v)
+ return rewriteValueAMD64_OpAMD64SHLQ_0(v)
case OpAMD64SHLQconst:
- return rewriteValueAMD64_OpAMD64SHLQconst(v)
+ return rewriteValueAMD64_OpAMD64SHLQconst_0(v)
case OpAMD64SHRB:
- return rewriteValueAMD64_OpAMD64SHRB(v)
+ return rewriteValueAMD64_OpAMD64SHRB_0(v)
case OpAMD64SHRBconst:
- return rewriteValueAMD64_OpAMD64SHRBconst(v)
+ return rewriteValueAMD64_OpAMD64SHRBconst_0(v)
case OpAMD64SHRL:
- return rewriteValueAMD64_OpAMD64SHRL(v)
+ return rewriteValueAMD64_OpAMD64SHRL_0(v)
case OpAMD64SHRLconst:
- return rewriteValueAMD64_OpAMD64SHRLconst(v)
+ return rewriteValueAMD64_OpAMD64SHRLconst_0(v)
case OpAMD64SHRQ:
- return rewriteValueAMD64_OpAMD64SHRQ(v)
+ return rewriteValueAMD64_OpAMD64SHRQ_0(v)
case OpAMD64SHRQconst:
- return rewriteValueAMD64_OpAMD64SHRQconst(v)
+ return rewriteValueAMD64_OpAMD64SHRQconst_0(v)
case OpAMD64SHRW:
- return rewriteValueAMD64_OpAMD64SHRW(v)
+ return rewriteValueAMD64_OpAMD64SHRW_0(v)
case OpAMD64SHRWconst:
- return rewriteValueAMD64_OpAMD64SHRWconst(v)
+ return rewriteValueAMD64_OpAMD64SHRWconst_0(v)
case OpAMD64SUBL:
- return rewriteValueAMD64_OpAMD64SUBL(v)
+ return rewriteValueAMD64_OpAMD64SUBL_0(v)
case OpAMD64SUBLconst:
- return rewriteValueAMD64_OpAMD64SUBLconst(v)
+ return rewriteValueAMD64_OpAMD64SUBLconst_0(v)
case OpAMD64SUBQ:
- return rewriteValueAMD64_OpAMD64SUBQ(v)
+ return rewriteValueAMD64_OpAMD64SUBQ_0(v)
case OpAMD64SUBQconst:
- return rewriteValueAMD64_OpAMD64SUBQconst(v)
+ return rewriteValueAMD64_OpAMD64SUBQconst_0(v)
case OpAMD64SUBSD:
- return rewriteValueAMD64_OpAMD64SUBSD(v)
+ return rewriteValueAMD64_OpAMD64SUBSD_0(v)
case OpAMD64SUBSS:
- return rewriteValueAMD64_OpAMD64SUBSS(v)
+ return rewriteValueAMD64_OpAMD64SUBSS_0(v)
case OpAMD64TESTB:
- return rewriteValueAMD64_OpAMD64TESTB(v)
+ return rewriteValueAMD64_OpAMD64TESTB_0(v)
case OpAMD64TESTL:
- return rewriteValueAMD64_OpAMD64TESTL(v)
+ return rewriteValueAMD64_OpAMD64TESTL_0(v)
case OpAMD64TESTQ:
- return rewriteValueAMD64_OpAMD64TESTQ(v)
+ return rewriteValueAMD64_OpAMD64TESTQ_0(v)
case OpAMD64TESTW:
- return rewriteValueAMD64_OpAMD64TESTW(v)
+ return rewriteValueAMD64_OpAMD64TESTW_0(v)
case OpAMD64XADDLlock:
- return rewriteValueAMD64_OpAMD64XADDLlock(v)
+ return rewriteValueAMD64_OpAMD64XADDLlock_0(v)
case OpAMD64XADDQlock:
- return rewriteValueAMD64_OpAMD64XADDQlock(v)
+ return rewriteValueAMD64_OpAMD64XADDQlock_0(v)
case OpAMD64XCHGL:
- return rewriteValueAMD64_OpAMD64XCHGL(v)
+ return rewriteValueAMD64_OpAMD64XCHGL_0(v)
case OpAMD64XCHGQ:
- return rewriteValueAMD64_OpAMD64XCHGQ(v)
+ return rewriteValueAMD64_OpAMD64XCHGQ_0(v)
case OpAMD64XORL:
- return rewriteValueAMD64_OpAMD64XORL(v)
+ return rewriteValueAMD64_OpAMD64XORL_0(v) || rewriteValueAMD64_OpAMD64XORL_10(v)
case OpAMD64XORLconst:
- return rewriteValueAMD64_OpAMD64XORLconst(v)
+ return rewriteValueAMD64_OpAMD64XORLconst_0(v)
case OpAMD64XORQ:
- return rewriteValueAMD64_OpAMD64XORQ(v)
+ return rewriteValueAMD64_OpAMD64XORQ_0(v)
case OpAMD64XORQconst:
- return rewriteValueAMD64_OpAMD64XORQconst(v)
+ return rewriteValueAMD64_OpAMD64XORQconst_0(v)
case OpAdd16:
- return rewriteValueAMD64_OpAdd16(v)
+ return rewriteValueAMD64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueAMD64_OpAdd32(v)
+ return rewriteValueAMD64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueAMD64_OpAdd32F(v)
+ return rewriteValueAMD64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueAMD64_OpAdd64(v)
+ return rewriteValueAMD64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueAMD64_OpAdd64F(v)
+ return rewriteValueAMD64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueAMD64_OpAdd8(v)
+ return rewriteValueAMD64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueAMD64_OpAddPtr(v)
+ return rewriteValueAMD64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueAMD64_OpAddr(v)
+ return rewriteValueAMD64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueAMD64_OpAnd16(v)
+ return rewriteValueAMD64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueAMD64_OpAnd32(v)
+ return rewriteValueAMD64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueAMD64_OpAnd64(v)
+ return rewriteValueAMD64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueAMD64_OpAnd8(v)
+ return rewriteValueAMD64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueAMD64_OpAndB(v)
+ return rewriteValueAMD64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueAMD64_OpAtomicAdd32(v)
+ return rewriteValueAMD64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueAMD64_OpAtomicAdd64(v)
+ return rewriteValueAMD64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValueAMD64_OpAtomicAnd8(v)
+ return rewriteValueAMD64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueAMD64_OpAtomicCompareAndSwap32(v)
+ return rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueAMD64_OpAtomicCompareAndSwap64(v)
+ return rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueAMD64_OpAtomicExchange32(v)
+ return rewriteValueAMD64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueAMD64_OpAtomicExchange64(v)
+ return rewriteValueAMD64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueAMD64_OpAtomicLoad32(v)
+ return rewriteValueAMD64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueAMD64_OpAtomicLoad64(v)
+ return rewriteValueAMD64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueAMD64_OpAtomicLoadPtr(v)
+ return rewriteValueAMD64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValueAMD64_OpAtomicOr8(v)
+ return rewriteValueAMD64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValueAMD64_OpAtomicStore32(v)
+ return rewriteValueAMD64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueAMD64_OpAtomicStore64(v)
+ return rewriteValueAMD64_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueAMD64_OpAtomicStorePtrNoWB(v)
+ return rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueAMD64_OpAvg64u(v)
+ return rewriteValueAMD64_OpAvg64u_0(v)
case OpBitLen32:
- return rewriteValueAMD64_OpBitLen32(v)
+ return rewriteValueAMD64_OpBitLen32_0(v)
case OpBitLen64:
- return rewriteValueAMD64_OpBitLen64(v)
+ return rewriteValueAMD64_OpBitLen64_0(v)
case OpBswap32:
- return rewriteValueAMD64_OpBswap32(v)
+ return rewriteValueAMD64_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueAMD64_OpBswap64(v)
+ return rewriteValueAMD64_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueAMD64_OpClosureCall(v)
+ return rewriteValueAMD64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueAMD64_OpCom16(v)
+ return rewriteValueAMD64_OpCom16_0(v)
case OpCom32:
- return rewriteValueAMD64_OpCom32(v)
+ return rewriteValueAMD64_OpCom32_0(v)
case OpCom64:
- return rewriteValueAMD64_OpCom64(v)
+ return rewriteValueAMD64_OpCom64_0(v)
case OpCom8:
- return rewriteValueAMD64_OpCom8(v)
+ return rewriteValueAMD64_OpCom8_0(v)
case OpConst16:
- return rewriteValueAMD64_OpConst16(v)
+ return rewriteValueAMD64_OpConst16_0(v)
case OpConst32:
- return rewriteValueAMD64_OpConst32(v)
+ return rewriteValueAMD64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueAMD64_OpConst32F(v)
+ return rewriteValueAMD64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueAMD64_OpConst64(v)
+ return rewriteValueAMD64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueAMD64_OpConst64F(v)
+ return rewriteValueAMD64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueAMD64_OpConst8(v)
+ return rewriteValueAMD64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueAMD64_OpConstBool(v)
+ return rewriteValueAMD64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueAMD64_OpConstNil(v)
+ return rewriteValueAMD64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueAMD64_OpConvert(v)
+ return rewriteValueAMD64_OpConvert_0(v)
case OpCtz32:
- return rewriteValueAMD64_OpCtz32(v)
+ return rewriteValueAMD64_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueAMD64_OpCtz64(v)
+ return rewriteValueAMD64_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueAMD64_OpCvt32Fto32(v)
+ return rewriteValueAMD64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueAMD64_OpCvt32Fto64(v)
+ return rewriteValueAMD64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueAMD64_OpCvt32Fto64F(v)
+ return rewriteValueAMD64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueAMD64_OpCvt32to32F(v)
+ return rewriteValueAMD64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueAMD64_OpCvt32to64F(v)
+ return rewriteValueAMD64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueAMD64_OpCvt64Fto32(v)
+ return rewriteValueAMD64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueAMD64_OpCvt64Fto32F(v)
+ return rewriteValueAMD64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueAMD64_OpCvt64Fto64(v)
+ return rewriteValueAMD64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueAMD64_OpCvt64to32F(v)
+ return rewriteValueAMD64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueAMD64_OpCvt64to64F(v)
+ return rewriteValueAMD64_OpCvt64to64F_0(v)
case OpDiv128u:
- return rewriteValueAMD64_OpDiv128u(v)
+ return rewriteValueAMD64_OpDiv128u_0(v)
case OpDiv16:
- return rewriteValueAMD64_OpDiv16(v)
+ return rewriteValueAMD64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueAMD64_OpDiv16u(v)
+ return rewriteValueAMD64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueAMD64_OpDiv32(v)
+ return rewriteValueAMD64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueAMD64_OpDiv32F(v)
+ return rewriteValueAMD64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueAMD64_OpDiv32u(v)
+ return rewriteValueAMD64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueAMD64_OpDiv64(v)
+ return rewriteValueAMD64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueAMD64_OpDiv64F(v)
+ return rewriteValueAMD64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueAMD64_OpDiv64u(v)
+ return rewriteValueAMD64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueAMD64_OpDiv8(v)
+ return rewriteValueAMD64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueAMD64_OpDiv8u(v)
+ return rewriteValueAMD64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueAMD64_OpEq16(v)
+ return rewriteValueAMD64_OpEq16_0(v)
case OpEq32:
- return rewriteValueAMD64_OpEq32(v)
+ return rewriteValueAMD64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueAMD64_OpEq32F(v)
+ return rewriteValueAMD64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueAMD64_OpEq64(v)
+ return rewriteValueAMD64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueAMD64_OpEq64F(v)
+ return rewriteValueAMD64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueAMD64_OpEq8(v)
+ return rewriteValueAMD64_OpEq8_0(v)
case OpEqB:
- return rewriteValueAMD64_OpEqB(v)
+ return rewriteValueAMD64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueAMD64_OpEqPtr(v)
+ return rewriteValueAMD64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueAMD64_OpGeq16(v)
+ return rewriteValueAMD64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueAMD64_OpGeq16U(v)
+ return rewriteValueAMD64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueAMD64_OpGeq32(v)
+ return rewriteValueAMD64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueAMD64_OpGeq32F(v)
+ return rewriteValueAMD64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueAMD64_OpGeq32U(v)
+ return rewriteValueAMD64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueAMD64_OpGeq64(v)
+ return rewriteValueAMD64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueAMD64_OpGeq64F(v)
+ return rewriteValueAMD64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueAMD64_OpGeq64U(v)
+ return rewriteValueAMD64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueAMD64_OpGeq8(v)
+ return rewriteValueAMD64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueAMD64_OpGeq8U(v)
+ return rewriteValueAMD64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueAMD64_OpGetClosurePtr(v)
+ return rewriteValueAMD64_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValueAMD64_OpGetG(v)
+ return rewriteValueAMD64_OpGetG_0(v)
case OpGreater16:
- return rewriteValueAMD64_OpGreater16(v)
+ return rewriteValueAMD64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueAMD64_OpGreater16U(v)
+ return rewriteValueAMD64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueAMD64_OpGreater32(v)
+ return rewriteValueAMD64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueAMD64_OpGreater32F(v)
+ return rewriteValueAMD64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueAMD64_OpGreater32U(v)
+ return rewriteValueAMD64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueAMD64_OpGreater64(v)
+ return rewriteValueAMD64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueAMD64_OpGreater64F(v)
+ return rewriteValueAMD64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueAMD64_OpGreater64U(v)
+ return rewriteValueAMD64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueAMD64_OpGreater8(v)
+ return rewriteValueAMD64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueAMD64_OpGreater8U(v)
+ return rewriteValueAMD64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueAMD64_OpHmul32(v)
+ return rewriteValueAMD64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueAMD64_OpHmul32u(v)
+ return rewriteValueAMD64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueAMD64_OpHmul64(v)
+ return rewriteValueAMD64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueAMD64_OpHmul64u(v)
+ return rewriteValueAMD64_OpHmul64u_0(v)
case OpInt64Hi:
- return rewriteValueAMD64_OpInt64Hi(v)
+ return rewriteValueAMD64_OpInt64Hi_0(v)
case OpInterCall:
- return rewriteValueAMD64_OpInterCall(v)
+ return rewriteValueAMD64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueAMD64_OpIsInBounds(v)
+ return rewriteValueAMD64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueAMD64_OpIsNonNil(v)
+ return rewriteValueAMD64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueAMD64_OpIsSliceInBounds(v)
+ return rewriteValueAMD64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueAMD64_OpLeq16(v)
+ return rewriteValueAMD64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueAMD64_OpLeq16U(v)
+ return rewriteValueAMD64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueAMD64_OpLeq32(v)
+ return rewriteValueAMD64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueAMD64_OpLeq32F(v)
+ return rewriteValueAMD64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueAMD64_OpLeq32U(v)
+ return rewriteValueAMD64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueAMD64_OpLeq64(v)
+ return rewriteValueAMD64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueAMD64_OpLeq64F(v)
+ return rewriteValueAMD64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueAMD64_OpLeq64U(v)
+ return rewriteValueAMD64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueAMD64_OpLeq8(v)
+ return rewriteValueAMD64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueAMD64_OpLeq8U(v)
+ return rewriteValueAMD64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueAMD64_OpLess16(v)
+ return rewriteValueAMD64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueAMD64_OpLess16U(v)
+ return rewriteValueAMD64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueAMD64_OpLess32(v)
+ return rewriteValueAMD64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueAMD64_OpLess32F(v)
+ return rewriteValueAMD64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueAMD64_OpLess32U(v)
+ return rewriteValueAMD64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueAMD64_OpLess64(v)
+ return rewriteValueAMD64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueAMD64_OpLess64F(v)
+ return rewriteValueAMD64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueAMD64_OpLess64U(v)
+ return rewriteValueAMD64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueAMD64_OpLess8(v)
+ return rewriteValueAMD64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueAMD64_OpLess8U(v)
+ return rewriteValueAMD64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueAMD64_OpLoad(v)
+ return rewriteValueAMD64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueAMD64_OpLsh16x16(v)
+ return rewriteValueAMD64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueAMD64_OpLsh16x32(v)
+ return rewriteValueAMD64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueAMD64_OpLsh16x64(v)
+ return rewriteValueAMD64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueAMD64_OpLsh16x8(v)
+ return rewriteValueAMD64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueAMD64_OpLsh32x16(v)
+ return rewriteValueAMD64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueAMD64_OpLsh32x32(v)
+ return rewriteValueAMD64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueAMD64_OpLsh32x64(v)
+ return rewriteValueAMD64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueAMD64_OpLsh32x8(v)
+ return rewriteValueAMD64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueAMD64_OpLsh64x16(v)
+ return rewriteValueAMD64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueAMD64_OpLsh64x32(v)
+ return rewriteValueAMD64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueAMD64_OpLsh64x64(v)
+ return rewriteValueAMD64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueAMD64_OpLsh64x8(v)
+ return rewriteValueAMD64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueAMD64_OpLsh8x16(v)
+ return rewriteValueAMD64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueAMD64_OpLsh8x32(v)
+ return rewriteValueAMD64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueAMD64_OpLsh8x64(v)
+ return rewriteValueAMD64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueAMD64_OpLsh8x8(v)
+ return rewriteValueAMD64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueAMD64_OpMod16(v)
+ return rewriteValueAMD64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueAMD64_OpMod16u(v)
+ return rewriteValueAMD64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueAMD64_OpMod32(v)
+ return rewriteValueAMD64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueAMD64_OpMod32u(v)
+ return rewriteValueAMD64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueAMD64_OpMod64(v)
+ return rewriteValueAMD64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueAMD64_OpMod64u(v)
+ return rewriteValueAMD64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueAMD64_OpMod8(v)
+ return rewriteValueAMD64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueAMD64_OpMod8u(v)
+ return rewriteValueAMD64_OpMod8u_0(v)
case OpMove:
- return rewriteValueAMD64_OpMove(v)
+ return rewriteValueAMD64_OpMove_0(v) || rewriteValueAMD64_OpMove_10(v)
case OpMul16:
- return rewriteValueAMD64_OpMul16(v)
+ return rewriteValueAMD64_OpMul16_0(v)
case OpMul32:
- return rewriteValueAMD64_OpMul32(v)
+ return rewriteValueAMD64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueAMD64_OpMul32F(v)
+ return rewriteValueAMD64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueAMD64_OpMul64(v)
+ return rewriteValueAMD64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueAMD64_OpMul64F(v)
+ return rewriteValueAMD64_OpMul64F_0(v)
case OpMul64uhilo:
- return rewriteValueAMD64_OpMul64uhilo(v)
+ return rewriteValueAMD64_OpMul64uhilo_0(v)
case OpMul8:
- return rewriteValueAMD64_OpMul8(v)
+ return rewriteValueAMD64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueAMD64_OpNeg16(v)
+ return rewriteValueAMD64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueAMD64_OpNeg32(v)
+ return rewriteValueAMD64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueAMD64_OpNeg32F(v)
+ return rewriteValueAMD64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueAMD64_OpNeg64(v)
+ return rewriteValueAMD64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueAMD64_OpNeg64F(v)
+ return rewriteValueAMD64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueAMD64_OpNeg8(v)
+ return rewriteValueAMD64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueAMD64_OpNeq16(v)
+ return rewriteValueAMD64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueAMD64_OpNeq32(v)
+ return rewriteValueAMD64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueAMD64_OpNeq32F(v)
+ return rewriteValueAMD64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueAMD64_OpNeq64(v)
+ return rewriteValueAMD64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueAMD64_OpNeq64F(v)
+ return rewriteValueAMD64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueAMD64_OpNeq8(v)
+ return rewriteValueAMD64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueAMD64_OpNeqB(v)
+ return rewriteValueAMD64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueAMD64_OpNeqPtr(v)
+ return rewriteValueAMD64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueAMD64_OpNilCheck(v)
+ return rewriteValueAMD64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueAMD64_OpNot(v)
+ return rewriteValueAMD64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueAMD64_OpOffPtr(v)
+ return rewriteValueAMD64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueAMD64_OpOr16(v)
+ return rewriteValueAMD64_OpOr16_0(v)
case OpOr32:
- return rewriteValueAMD64_OpOr32(v)
+ return rewriteValueAMD64_OpOr32_0(v)
case OpOr64:
- return rewriteValueAMD64_OpOr64(v)
+ return rewriteValueAMD64_OpOr64_0(v)
case OpOr8:
- return rewriteValueAMD64_OpOr8(v)
+ return rewriteValueAMD64_OpOr8_0(v)
case OpOrB:
- return rewriteValueAMD64_OpOrB(v)
+ return rewriteValueAMD64_OpOrB_0(v)
case OpPopCount16:
- return rewriteValueAMD64_OpPopCount16(v)
+ return rewriteValueAMD64_OpPopCount16_0(v)
case OpPopCount32:
- return rewriteValueAMD64_OpPopCount32(v)
+ return rewriteValueAMD64_OpPopCount32_0(v)
case OpPopCount64:
- return rewriteValueAMD64_OpPopCount64(v)
+ return rewriteValueAMD64_OpPopCount64_0(v)
case OpPopCount8:
- return rewriteValueAMD64_OpPopCount8(v)
+ return rewriteValueAMD64_OpPopCount8_0(v)
case OpRound32F:
- return rewriteValueAMD64_OpRound32F(v)
+ return rewriteValueAMD64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueAMD64_OpRound64F(v)
+ return rewriteValueAMD64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueAMD64_OpRsh16Ux16(v)
+ return rewriteValueAMD64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueAMD64_OpRsh16Ux32(v)
+ return rewriteValueAMD64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueAMD64_OpRsh16Ux64(v)
+ return rewriteValueAMD64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueAMD64_OpRsh16Ux8(v)
+ return rewriteValueAMD64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueAMD64_OpRsh16x16(v)
+ return rewriteValueAMD64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueAMD64_OpRsh16x32(v)
+ return rewriteValueAMD64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueAMD64_OpRsh16x64(v)
+ return rewriteValueAMD64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueAMD64_OpRsh16x8(v)
+ return rewriteValueAMD64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueAMD64_OpRsh32Ux16(v)
+ return rewriteValueAMD64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueAMD64_OpRsh32Ux32(v)
+ return rewriteValueAMD64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueAMD64_OpRsh32Ux64(v)
+ return rewriteValueAMD64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueAMD64_OpRsh32Ux8(v)
+ return rewriteValueAMD64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueAMD64_OpRsh32x16(v)
+ return rewriteValueAMD64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueAMD64_OpRsh32x32(v)
+ return rewriteValueAMD64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueAMD64_OpRsh32x64(v)
+ return rewriteValueAMD64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueAMD64_OpRsh32x8(v)
+ return rewriteValueAMD64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueAMD64_OpRsh64Ux16(v)
+ return rewriteValueAMD64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueAMD64_OpRsh64Ux32(v)
+ return rewriteValueAMD64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueAMD64_OpRsh64Ux64(v)
+ return rewriteValueAMD64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueAMD64_OpRsh64Ux8(v)
+ return rewriteValueAMD64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueAMD64_OpRsh64x16(v)
+ return rewriteValueAMD64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueAMD64_OpRsh64x32(v)
+ return rewriteValueAMD64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueAMD64_OpRsh64x64(v)
+ return rewriteValueAMD64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueAMD64_OpRsh64x8(v)
+ return rewriteValueAMD64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueAMD64_OpRsh8Ux16(v)
+ return rewriteValueAMD64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueAMD64_OpRsh8Ux32(v)
+ return rewriteValueAMD64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueAMD64_OpRsh8Ux64(v)
+ return rewriteValueAMD64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueAMD64_OpRsh8Ux8(v)
+ return rewriteValueAMD64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueAMD64_OpRsh8x16(v)
+ return rewriteValueAMD64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueAMD64_OpRsh8x32(v)
+ return rewriteValueAMD64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueAMD64_OpRsh8x64(v)
+ return rewriteValueAMD64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueAMD64_OpRsh8x8(v)
+ return rewriteValueAMD64_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueAMD64_OpSelect0(v)
+ return rewriteValueAMD64_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueAMD64_OpSelect1(v)
+ return rewriteValueAMD64_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueAMD64_OpSignExt16to32(v)
+ return rewriteValueAMD64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueAMD64_OpSignExt16to64(v)
+ return rewriteValueAMD64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueAMD64_OpSignExt32to64(v)
+ return rewriteValueAMD64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueAMD64_OpSignExt8to16(v)
+ return rewriteValueAMD64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueAMD64_OpSignExt8to32(v)
+ return rewriteValueAMD64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueAMD64_OpSignExt8to64(v)
+ return rewriteValueAMD64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueAMD64_OpSlicemask(v)
+ return rewriteValueAMD64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueAMD64_OpSqrt(v)
+ return rewriteValueAMD64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueAMD64_OpStaticCall(v)
+ return rewriteValueAMD64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueAMD64_OpStore(v)
+ return rewriteValueAMD64_OpStore_0(v)
case OpSub16:
- return rewriteValueAMD64_OpSub16(v)
+ return rewriteValueAMD64_OpSub16_0(v)
case OpSub32:
- return rewriteValueAMD64_OpSub32(v)
+ return rewriteValueAMD64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueAMD64_OpSub32F(v)
+ return rewriteValueAMD64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueAMD64_OpSub64(v)
+ return rewriteValueAMD64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueAMD64_OpSub64F(v)
+ return rewriteValueAMD64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueAMD64_OpSub8(v)
+ return rewriteValueAMD64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueAMD64_OpSubPtr(v)
+ return rewriteValueAMD64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueAMD64_OpTrunc16to8(v)
+ return rewriteValueAMD64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueAMD64_OpTrunc32to16(v)
+ return rewriteValueAMD64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueAMD64_OpTrunc32to8(v)
+ return rewriteValueAMD64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueAMD64_OpTrunc64to16(v)
+ return rewriteValueAMD64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueAMD64_OpTrunc64to32(v)
+ return rewriteValueAMD64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueAMD64_OpTrunc64to8(v)
+ return rewriteValueAMD64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueAMD64_OpXor16(v)
+ return rewriteValueAMD64_OpXor16_0(v)
case OpXor32:
- return rewriteValueAMD64_OpXor32(v)
+ return rewriteValueAMD64_OpXor32_0(v)
case OpXor64:
- return rewriteValueAMD64_OpXor64(v)
+ return rewriteValueAMD64_OpXor64_0(v)
case OpXor8:
- return rewriteValueAMD64_OpXor8(v)
+ return rewriteValueAMD64_OpXor8_0(v)
case OpZero:
- return rewriteValueAMD64_OpZero(v)
+ return rewriteValueAMD64_OpZero_0(v) || rewriteValueAMD64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueAMD64_OpZeroExt16to32(v)
+ return rewriteValueAMD64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueAMD64_OpZeroExt16to64(v)
+ return rewriteValueAMD64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueAMD64_OpZeroExt32to64(v)
+ return rewriteValueAMD64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueAMD64_OpZeroExt8to16(v)
+ return rewriteValueAMD64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueAMD64_OpZeroExt8to32(v)
+ return rewriteValueAMD64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueAMD64_OpZeroExt8to64(v)
+ return rewriteValueAMD64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool {
// match: (ADDL x (MOVLconst [c]))
// cond:
// result: (ADDLconst [c] x)
@@ -1077,6 +1077,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool {
// match: (ADDL x l:(MOVLload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDLmem x [off] {sym} ptr mem)
@@ -1127,7 +1130,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool {
// match: (ADDLconst [c] x)
// cond: int32(c)==0
// result: x
@@ -1195,7 +1198,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool {
// match: (ADDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ADDQconst [c] x)
@@ -1392,6 +1395,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool {
// match: (ADDQ x (ADDQ y y))
// cond:
// result: (LEAQ2 x y)
@@ -1578,6 +1584,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_20(v *Value) bool {
// match: (ADDQ x (NEGQ y))
// cond:
// result: (SUBQ x y)
@@ -1658,7 +1667,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool {
// match: (ADDQconst [c] (ADDQ x y))
// cond:
// result: (LEAQ1 [c] x y)
@@ -1837,7 +1846,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool {
// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDSDmem x [off] {sym} ptr mem)
@@ -1888,7 +1897,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool {
// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDSSmem x [off] {sym} ptr mem)
@@ -1939,7 +1948,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool {
// match: (ANDL x (MOVLconst [c]))
// cond:
// result: (ANDLconst [c] x)
@@ -2033,7 +2042,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool {
// match: (ANDLconst [c] (ANDLconst [d] x))
// cond:
// result: (ANDLconst [c & d] x)
@@ -2116,7 +2125,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool {
// match: (ANDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ANDQconst [c] x)
@@ -2216,7 +2225,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool {
// match: (ANDQconst [c] (ANDQconst [d] x))
// cond:
// result: (ANDQconst [c & d] x)
@@ -2309,7 +2318,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x)))
@@ -2362,7 +2371,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTQconst_0(v *Value) bool {
// match: (BTQconst [c] x)
// cond: c < 32
// result: (BTLconst [c] x)
@@ -2379,7 +2388,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQEQ_0(v *Value) bool {
// match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _))))
// cond: c != 0
// result: x
@@ -2408,7 +2417,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPB_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPB x (MOVLconst [c]))
@@ -2445,7 +2454,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBconst_0(v *Value) bool {
// match: (CMPBconst (MOVLconst [x]) [y])
// cond: int8(x)==int8(y)
// result: (FlagEQ)
@@ -2593,7 +2602,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPL x (MOVLconst [c]))
@@ -2630,7 +2639,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLconst_0(v *Value) bool {
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -2794,7 +2803,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPQ x (MOVQconst [c]))
@@ -2837,7 +2846,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQconst_0(v *Value) bool {
// match: (CMPQconst (NEGQ (ADDQconst [-16] (ANDQconst [15] _))) [32])
// cond:
// result: (FlagLT_ULT)
@@ -3019,6 +3028,9 @@
v.reset(OpAMD64FlagLT_ULT)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPQconst_10(v *Value) bool {
// match: (CMPQconst (SHRQconst _ [c]) [n])
// cond: 0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)
// result: (FlagLT_ULT)
@@ -3118,7 +3130,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVLconst [c]))
@@ -3155,7 +3167,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVLconst [x]) [y])
// cond: int16(x)==int16(y)
// result: (FlagEQ)
@@ -3303,7 +3315,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v *Value) bool {
// match: (CMPXCHGLlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
// cond: is32Bit(off1+off2)
// result: (CMPXCHGLlock [off1+off2] {sym} ptr old new_ mem)
@@ -3333,7 +3345,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v *Value) bool {
// match: (CMPXCHGQlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
// cond: is32Bit(off1+off2)
// result: (CMPXCHGQlock [off1+off2] {sym} ptr old new_ mem)
@@ -3363,7 +3375,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL_0(v *Value) bool {
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAL [c+d] {s} x)
@@ -3387,7 +3399,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ_0(v *Value) bool {
// match: (LEAQ [c] {s} (ADDQconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAQ [c+d] {s} x)
@@ -3551,7 +3563,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ1_0(v *Value) bool {
// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ1 [c+d] {s} x y)
@@ -3780,7 +3792,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ2_0(v *Value) bool {
// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ2 [c+d] {s} x y)
@@ -3897,7 +3909,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ4_0(v *Value) bool {
// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ4 [c+d] {s} x y)
@@ -3992,7 +4004,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ8_0(v *Value) bool {
// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ8 [c+d] {s} x y)
@@ -4065,7 +4077,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem))
@@ -4201,7 +4213,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSXload_0(v *Value) bool {
// match: (MOVBQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVBQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -4228,7 +4240,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem))
@@ -4388,7 +4400,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBload_0(v *Value) bool {
// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
@@ -4558,7 +4570,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v *Value) bool {
// match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
@@ -4649,7 +4661,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstore_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
@@ -5142,6 +5154,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstore_10(v *Value) bool {
// match: (MOVBstore [i] {s} p (SHRQconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstore [i-1] {s} p w mem)
@@ -5286,7 +5301,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v *Value) bool {
// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -5459,7 +5474,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v *Value) bool {
// match: (MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond:
// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -5540,7 +5555,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -6053,7 +6068,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem))
@@ -6165,7 +6180,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSXload_0(v *Value) bool {
// match: (MOVLQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVLQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -6192,7 +6207,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem))
@@ -6355,7 +6370,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLatomicload_0(v *Value) bool {
// match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVLatomicload [off1+off2] {sym} ptr mem)
@@ -6405,7 +6420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLload_0(v *Value) bool {
// match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
@@ -6601,7 +6616,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v *Value) bool {
// match: (MOVLloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond:
// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
@@ -6740,7 +6755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v *Value) bool {
// match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
@@ -6787,7 +6802,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstore_0(v *Value) bool {
// match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
// cond:
// result: (MOVLstore [off] {sym} ptr x mem)
@@ -7077,6 +7092,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstore_10(v *Value) bool {
// match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
@@ -7130,7 +7148,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7336,7 +7354,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7448,7 +7466,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7539,7 +7557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v *Value) bool {
// match: (MOVLstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
// cond:
// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
@@ -7717,7 +7735,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -7877,7 +7895,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOload_0(v *Value) bool {
// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVOload [off1+off2] {sym} ptr mem)
@@ -7927,7 +7945,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOstore_0(v *Value) bool {
// match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVOstore [off1+off2] {sym} ptr val mem)
@@ -7981,7 +7999,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQatomicload_0(v *Value) bool {
// match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVQatomicload [off1+off2] {sym} ptr mem)
@@ -8031,7 +8049,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQload_0(v *Value) bool {
// match: (MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
@@ -8227,7 +8245,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v *Value) bool {
// match: (MOVQloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVQloadidx8 [c] {sym} ptr idx mem)
@@ -8366,7 +8384,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v *Value) bool {
// match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVQloadidx8 [c+d] {sym} ptr idx mem)
@@ -8413,7 +8431,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstore_0(v *Value) bool {
// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVQstore [off1+off2] {sym} ptr val mem)
@@ -8623,7 +8641,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v *Value) bool {
// match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -8793,7 +8811,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v *Value) bool {
// match: (MOVQstoreconstidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVQstoreconstidx8 [c] {sym} ptr idx mem)
@@ -8864,7 +8882,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v *Value) bool {
// match: (MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond:
// result: (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem)
@@ -8911,7 +8929,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v *Value) bool {
// match: (MOVQstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
// cond:
// result: (MOVQstoreidx8 [c] {sym} ptr idx val mem)
@@ -8988,7 +9006,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v *Value) bool {
// match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -9039,7 +9057,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDload_0(v *Value) bool {
// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVSDload [off1+off2] {sym} ptr mem)
@@ -9165,7 +9183,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v *Value) bool {
// match: (MOVSDloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVSDloadidx8 [c] {sym} ptr idx mem)
@@ -9236,7 +9254,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v *Value) bool {
// match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
@@ -9283,7 +9301,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstore_0(v *Value) bool {
// match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVSDstore [off1+off2] {sym} ptr val mem)
@@ -9419,7 +9437,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v *Value) bool {
// match: (MOVSDstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
// cond:
// result: (MOVSDstoreidx8 [c] {sym} ptr idx val mem)
@@ -9496,7 +9514,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v *Value) bool {
// match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
@@ -9547,7 +9565,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSload_0(v *Value) bool {
// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVSSload [off1+off2] {sym} ptr mem)
@@ -9673,7 +9691,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v *Value) bool {
// match: (MOVSSloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond:
// result: (MOVSSloadidx4 [c] {sym} ptr idx mem)
@@ -9744,7 +9762,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v *Value) bool {
// match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
@@ -9791,7 +9809,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstore_0(v *Value) bool {
// match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVSSstore [off1+off2] {sym} ptr val mem)
@@ -9927,7 +9945,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v *Value) bool {
// match: (MOVSSstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
// cond:
// result: (MOVSSstoreidx4 [c] {sym} ptr idx val mem)
@@ -10004,7 +10022,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v *Value) bool {
// match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
@@ -10055,7 +10073,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem))
@@ -10179,7 +10197,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSXload_0(v *Value) bool {
// match: (MOVWQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVWQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
@@ -10206,7 +10224,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem))
@@ -10381,7 +10399,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWload_0(v *Value) bool {
// match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
@@ -10577,7 +10595,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v *Value) bool {
// match: (MOVWloadidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
// cond:
// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
@@ -10716,7 +10734,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v *Value) bool {
// match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
@@ -10763,7 +10781,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
@@ -11053,6 +11071,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstore_10(v *Value) bool {
// match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
@@ -11106,7 +11127,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v *Value) bool {
// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -11305,7 +11326,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v *Value) bool {
// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
// cond:
// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
@@ -11410,7 +11431,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem)
@@ -11496,7 +11517,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v *Value) bool {
// match: (MOVWstoreidx1 [c] {sym} ptr (SHLQconst [1] idx) val mem)
// cond:
// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
@@ -11674,7 +11695,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem)
@@ -11834,7 +11855,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULL_0(v *Value) bool {
// match: (MULL x (MOVLconst [c]))
// cond:
// result: (MULLconst [c] x)
@@ -11867,7 +11888,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULLconst_0(v *Value) bool {
// match: (MULLconst [c] (MULLconst [d] x))
// cond:
// result: (MULLconst [int64(int32(c * d))] x)
@@ -11900,7 +11921,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQ_0(v *Value) bool {
// match: (MULQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (MULQconst [c] x)
@@ -11939,7 +11960,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULQconst [c] (MULQconst [d] x))
@@ -12083,6 +12104,11 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULQconst [21] x)
// cond:
// result: (LEAQ4 x (LEAQ4 <v.Type> x x))
@@ -12245,6 +12271,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULQconst [c] x)
// cond: isPowerOfTwo(c-8) && c >= 136
// result: (LEAQ8 (SHLQconst <v.Type> [log2(c-8)] x) x)
@@ -12329,7 +12360,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool {
// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (MULSDmem x [off] {sym} ptr mem)
@@ -12380,7 +12411,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool {
// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (MULSSmem x [off] {sym} ptr mem)
@@ -12431,7 +12462,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool {
// match: (NEGL (MOVLconst [c]))
// cond:
// result: (MOVLconst [int64(int32(-c))])
@@ -12447,7 +12478,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool {
// match: (NEGQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [-c])
@@ -12485,7 +12516,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool {
// match: (NOTL (MOVLconst [c]))
// cond:
// result: (MOVLconst [^c])
@@ -12501,7 +12532,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool {
// match: (NOTQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [^c])
@@ -12517,11 +12548,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool {
// match: (ORL x (MOVLconst [c]))
// cond:
// result: (ORLconst [c] x)
@@ -12842,6 +12869,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool {
// match: (ORL (ANDL (SHRL x (NEGQ y)) (SBBLcarrymask (CMPQconst (NEGQ (ADDQconst (ANDQconst y [31]) [-32])) [32]))) (SHLL x y))
// cond:
// result: (ROLL x y)
@@ -13492,6 +13522,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool {
// match: (ORL (SHRL x y) (ANDL (SHLL x (NEGL y)) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [31]) [-32])) [32]))))
// cond:
// result: (RORL x y)
@@ -14286,6 +14319,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool {
// match: (ORL (ANDL (SHRW x (NEGL (ADDLconst (ANDLconst y [15]) [-16]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [15]) [-16])) [16]))) (SHLL x (ANDLconst y [15])))
// cond: v.Type.Size() == 2
// result: (ROLW x y)
@@ -15032,6 +15068,13 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL (SHLL x (ANDLconst y [ 7])) (ANDL (SHRB x (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8])) [ 8]))))
// cond: v.Type.Size() == 1
// result: (ROLB x y)
@@ -15659,6 +15702,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
@@ -16190,6 +16240,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) sh:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -16700,6 +16757,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
@@ -17308,6 +17372,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORL y s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -17942,6 +18013,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [8] x0:(MOVBload [i0] {s} p mem)) x1:(MOVBload [i1] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWload [i0] {s} p mem))
@@ -18529,6 +18607,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x1:(MOVBloadidx1 [i1] {s} idx p mem) sh:(SHLLconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
@@ -19134,6 +19219,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
@@ -19811,6 +19903,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORL y s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -20447,6 +20546,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_130(v *Value) bool {
// match: (ORL l:(MOVLload [off] {sym} ptr mem) x)
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ORLmem x [off] {sym} ptr mem)
@@ -20473,7 +20575,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool {
// match: (ORLconst [c] x)
// cond: int32(c)==0
// result: x
@@ -20516,11 +20618,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool {
// match: (ORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ORQconst [c] x)
@@ -20999,6 +21097,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool {
// match: (ORQ (ANDQ (SHRQ x (NEGL y)) (SBBQcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [63]) [-64])) [64]))) (SHLQ x y))
// cond:
// result: (ROLQ x y)
@@ -21649,6 +21750,13 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ x x)
// cond:
// result: x
@@ -22118,6 +22226,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem))) s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWload [i0] {s} p mem)) y)
@@ -22673,6 +22788,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
@@ -23183,6 +23305,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
@@ -23707,6 +23836,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -24357,6 +24493,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
@@ -25007,6 +25150,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)) or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} p idx mem))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
@@ -25657,6 +25807,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
@@ -26245,6 +26402,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem))) s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWload [i0] {s} p mem))) y)
@@ -26882,6 +27046,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)) x1:(MOVBloadidx1 [i1] {s} p idx mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
@@ -27513,6 +27684,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
@@ -28136,6 +28314,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_130(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -28816,6 +29001,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_140(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))) s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -29561,6 +29753,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_150(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
@@ -30371,6 +30570,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_160(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))) s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
@@ -30502,7 +30708,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool {
// match: (ORQconst [0] x)
// cond:
// result: x
@@ -30543,7 +30749,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool {
// match: (ROLB x (NEGQ y))
// cond:
// result: (RORB x y)
@@ -30606,7 +30812,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool {
// match: (ROLBconst [c] (ROLBconst [d] x))
// cond:
// result: (ROLBconst [(c+d)& 7] x)
@@ -30638,7 +30844,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool {
// match: (ROLL x (NEGQ y))
// cond:
// result: (RORL x y)
@@ -30701,7 +30907,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool {
// match: (ROLLconst [c] (ROLLconst [d] x))
// cond:
// result: (ROLLconst [(c+d)&31] x)
@@ -30733,7 +30939,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool {
// match: (ROLQ x (NEGQ y))
// cond:
// result: (RORQ x y)
@@ -30796,7 +31002,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool {
// match: (ROLQconst [c] (ROLQconst [d] x))
// cond:
// result: (ROLQconst [(c+d)&63] x)
@@ -30828,7 +31034,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool {
// match: (ROLW x (NEGQ y))
// cond:
// result: (RORW x y)
@@ -30891,7 +31097,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool {
// match: (ROLWconst [c] (ROLWconst [d] x))
// cond:
// result: (ROLWconst [(c+d)&15] x)
@@ -30923,7 +31129,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool {
// match: (RORB x (NEGQ y))
// cond:
// result: (ROLB x y)
@@ -30986,7 +31192,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool {
// match: (RORL x (NEGQ y))
// cond:
// result: (ROLL x y)
@@ -31049,7 +31255,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool {
// match: (RORQ x (NEGQ y))
// cond:
// result: (ROLQ x y)
@@ -31112,7 +31318,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool {
// match: (RORW x (NEGQ y))
// cond:
// result: (ROLW x y)
@@ -31175,7 +31381,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool {
// match: (SARB x (MOVQconst [c]))
// cond:
// result: (SARBconst [min(c&31,7)] x)
@@ -31208,7 +31414,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool {
// match: (SARBconst x [0])
// cond:
// result: x
@@ -31238,7 +31444,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SARL x (MOVQconst [c]))
@@ -31453,7 +31659,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool {
// match: (SARLconst x [0])
// cond:
// result: x
@@ -31483,7 +31689,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SARQ x (MOVQconst [c]))
@@ -31698,7 +31904,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool {
// match: (SARQconst x [0])
// cond:
// result: x
@@ -31728,7 +31934,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool {
// match: (SARW x (MOVQconst [c]))
// cond:
// result: (SARWconst [min(c&31,15)] x)
@@ -31761,7 +31967,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool {
// match: (SARWconst x [0])
// cond:
// result: x
@@ -31791,7 +31997,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool {
// match: (SBBLcarrymask (FlagEQ))
// cond:
// result: (MOVLconst [0])
@@ -31854,7 +32060,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool {
// match: (SBBQcarrymask (FlagEQ))
// cond:
// result: (MOVQconst [0])
@@ -31917,7 +32123,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETA(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool {
// match: (SETA (InvertFlags x))
// cond:
// result: (SETB x)
@@ -31993,7 +32199,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool {
// match: (SETAE (InvertFlags x))
// cond:
// result: (SETBE x)
@@ -32069,7 +32275,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool {
// match: (SETB (InvertFlags x))
// cond:
// result: (SETA x)
@@ -32145,7 +32351,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool {
// match: (SETBE (InvertFlags x))
// cond:
// result: (SETAE x)
@@ -32221,7 +32427,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -32463,6 +32669,9 @@
v.AuxInt = 1
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool {
// match: (SETEQ (FlagLT_ULT))
// cond:
// result: (MOVLconst [0])
@@ -32513,7 +32722,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETG(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool {
// match: (SETG (InvertFlags x))
// cond:
// result: (SETL x)
@@ -32589,7 +32798,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool {
// match: (SETGE (InvertFlags x))
// cond:
// result: (SETLE x)
@@ -32665,7 +32874,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool {
// match: (SETL (InvertFlags x))
// cond:
// result: (SETG x)
@@ -32741,7 +32950,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool {
// match: (SETLE (InvertFlags x))
// cond:
// result: (SETGE x)
@@ -32817,7 +33026,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -33059,6 +33268,9 @@
v.AuxInt = 0
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool {
// match: (SETNE (FlagLT_ULT))
// cond:
// result: (MOVLconst [1])
@@ -33109,7 +33321,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHLL x (MOVQconst [c]))
@@ -33324,7 +33536,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool {
// match: (SHLLconst x [0])
// cond:
// result: x
@@ -33340,7 +33552,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHLQ x (MOVQconst [c]))
@@ -33555,7 +33767,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool {
// match: (SHLQconst x [0])
// cond:
// result: x
@@ -33571,7 +33783,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool {
// match: (SHRB x (MOVQconst [c]))
// cond: c&31 < 8
// result: (SHRBconst [c&31] x)
@@ -33642,7 +33854,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool {
// match: (SHRBconst x [0])
// cond:
// result: x
@@ -33658,7 +33870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHRL x (MOVQconst [c]))
@@ -33873,7 +34085,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool {
// match: (SHRLconst x [0])
// cond:
// result: x
@@ -33889,7 +34101,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHRQ x (MOVQconst [c]))
@@ -34104,7 +34316,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool {
// match: (SHRQconst x [0])
// cond:
// result: x
@@ -34120,7 +34332,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool {
// match: (SHRW x (MOVQconst [c]))
// cond: c&31 < 16
// result: (SHRWconst [c&31] x)
@@ -34191,7 +34403,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool {
// match: (SHRWconst x [0])
// cond:
// result: x
@@ -34207,7 +34419,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBL x (MOVLconst [c]))
@@ -34280,7 +34492,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool {
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
// result: x
@@ -34307,7 +34519,7 @@
return true
}
}
-func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBQ x (MOVQconst [c]))
@@ -34386,7 +34598,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool {
// match: (SUBQconst [0] x)
// cond:
// result: x
@@ -34449,7 +34661,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool {
// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (SUBSDmem x [off] {sym} ptr mem)
@@ -34476,7 +34688,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool {
// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (SUBSSmem x [off] {sym} ptr mem)
@@ -34503,7 +34715,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool {
// match: (TESTB (MOVLconst [c]) x)
// cond:
// result: (TESTBconst [c] x)
@@ -34536,7 +34748,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool {
// match: (TESTL (MOVLconst [c]) x)
// cond:
// result: (TESTLconst [c] x)
@@ -34569,7 +34781,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool {
// match: (TESTQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (TESTQconst [c] x)
@@ -34608,7 +34820,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool {
// match: (TESTW (MOVLconst [c]) x)
// cond:
// result: (TESTWconst [c] x)
@@ -34641,7 +34853,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool {
// match: (XADDLlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XADDLlock [off1+off2] {sym} val ptr mem)
@@ -34669,7 +34881,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool {
// match: (XADDQlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XADDQlock [off1+off2] {sym} val ptr mem)
@@ -34697,7 +34909,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool {
// match: (XCHGL [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XCHGL [off1+off2] {sym} val ptr mem)
@@ -34751,7 +34963,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool {
// match: (XCHGQ [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XCHGQ [off1+off2] {sym} val ptr mem)
@@ -34805,7 +35017,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool {
// match: (XORL x (MOVLconst [c]))
// cond:
// result: (XORLconst [c] x)
@@ -35032,6 +35244,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORL_10(v *Value) bool {
// match: (XORL l:(MOVLload [off] {sym} ptr mem) x)
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (XORLmem x [off] {sym} ptr mem)
@@ -35058,7 +35273,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool {
// match: (XORLconst [c] (XORLconst [d] x))
// cond:
// result: (XORLconst [c ^ d] x)
@@ -35105,7 +35320,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool {
// match: (XORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (XORQconst [c] x)
@@ -35256,7 +35471,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool {
// match: (XORQconst [c] (XORQconst [d] x))
// cond:
// result: (XORQconst [c ^ d] x)
@@ -35302,7 +35517,7 @@
}
return false
}
-func rewriteValueAMD64_OpAdd16(v *Value) bool {
+func rewriteValueAMD64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDL x y)
@@ -35315,7 +35530,7 @@
return true
}
}
-func rewriteValueAMD64_OpAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDL x y)
@@ -35328,7 +35543,7 @@
return true
}
}
-func rewriteValueAMD64_OpAdd32F(v *Value) bool {
+func rewriteValueAMD64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDSS x y)
@@ -35341,7 +35556,7 @@
return true
}
}
-func rewriteValueAMD64_OpAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADDQ x y)
@@ -35354,7 +35569,7 @@
return true
}
}
-func rewriteValueAMD64_OpAdd64F(v *Value) bool {
+func rewriteValueAMD64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDSD x y)
@@ -35367,7 +35582,7 @@
return true
}
}
-func rewriteValueAMD64_OpAdd8(v *Value) bool {
+func rewriteValueAMD64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDL x y)
@@ -35380,7 +35595,7 @@
return true
}
}
-func rewriteValueAMD64_OpAddPtr(v *Value) bool {
+func rewriteValueAMD64_OpAddPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -35415,7 +35630,7 @@
}
return false
}
-func rewriteValueAMD64_OpAddr(v *Value) bool {
+func rewriteValueAMD64_OpAddr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -35450,7 +35665,7 @@
}
return false
}
-func rewriteValueAMD64_OpAnd16(v *Value) bool {
+func rewriteValueAMD64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDL x y)
@@ -35463,7 +35678,7 @@
return true
}
}
-func rewriteValueAMD64_OpAnd32(v *Value) bool {
+func rewriteValueAMD64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDL x y)
@@ -35476,7 +35691,7 @@
return true
}
}
-func rewriteValueAMD64_OpAnd64(v *Value) bool {
+func rewriteValueAMD64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (ANDQ x y)
@@ -35489,7 +35704,7 @@
return true
}
}
-func rewriteValueAMD64_OpAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDL x y)
@@ -35502,7 +35717,7 @@
return true
}
}
-func rewriteValueAMD64_OpAndB(v *Value) bool {
+func rewriteValueAMD64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDL x y)
@@ -35515,7 +35730,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35537,7 +35752,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35559,7 +35774,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (ANDBlock ptr val mem)
@@ -35574,7 +35789,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (CMPXCHGLlock ptr old new_ mem)
@@ -35591,7 +35806,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (CMPXCHGQlock ptr old new_ mem)
@@ -35608,7 +35823,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (XCHGL val ptr mem)
@@ -35623,7 +35838,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (XCHGQ val ptr mem)
@@ -35638,7 +35853,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (MOVLatomicload ptr mem)
@@ -35651,7 +35866,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (MOVQatomicload ptr mem)
@@ -35664,7 +35879,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoadPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -35699,7 +35914,7 @@
}
return false
}
-func rewriteValueAMD64_OpAtomicOr8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (ORBlock ptr val mem)
@@ -35714,7 +35929,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35735,7 +35950,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35756,7 +35971,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -35801,7 +36016,7 @@
}
return false
}
-func rewriteValueAMD64_OpAvg64u(v *Value) bool {
+func rewriteValueAMD64_OpAvg64u_0(v *Value) bool {
// match: (Avg64u x y)
// cond:
// result: (AVGQU x y)
@@ -35814,7 +36029,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen32(v *Value) bool {
+func rewriteValueAMD64_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35831,7 +36046,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen64(v *Value) bool {
+func rewriteValueAMD64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -35862,7 +36077,7 @@
return true
}
}
-func rewriteValueAMD64_OpBswap32(v *Value) bool {
+func rewriteValueAMD64_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (BSWAPL x)
@@ -35873,7 +36088,7 @@
return true
}
}
-func rewriteValueAMD64_OpBswap64(v *Value) bool {
+func rewriteValueAMD64_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (BSWAPQ x)
@@ -35884,7 +36099,7 @@
return true
}
}
-func rewriteValueAMD64_OpClosureCall(v *Value) bool {
+func rewriteValueAMD64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -35901,7 +36116,7 @@
return true
}
}
-func rewriteValueAMD64_OpCom16(v *Value) bool {
+func rewriteValueAMD64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTL x)
@@ -35912,7 +36127,7 @@
return true
}
}
-func rewriteValueAMD64_OpCom32(v *Value) bool {
+func rewriteValueAMD64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTL x)
@@ -35923,7 +36138,7 @@
return true
}
}
-func rewriteValueAMD64_OpCom64(v *Value) bool {
+func rewriteValueAMD64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOTQ x)
@@ -35934,7 +36149,7 @@
return true
}
}
-func rewriteValueAMD64_OpCom8(v *Value) bool {
+func rewriteValueAMD64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTL x)
@@ -35945,7 +36160,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst16(v *Value) bool {
+func rewriteValueAMD64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVLconst [val])
@@ -35956,7 +36171,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst32(v *Value) bool {
+func rewriteValueAMD64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVLconst [val])
@@ -35967,7 +36182,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst32F(v *Value) bool {
+func rewriteValueAMD64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVSSconst [val])
@@ -35978,7 +36193,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst64(v *Value) bool {
+func rewriteValueAMD64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVQconst [val])
@@ -35989,7 +36204,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst64F(v *Value) bool {
+func rewriteValueAMD64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVSDconst [val])
@@ -36000,7 +36215,7 @@
return true
}
}
-func rewriteValueAMD64_OpConst8(v *Value) bool {
+func rewriteValueAMD64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVLconst [val])
@@ -36011,7 +36226,7 @@
return true
}
}
-func rewriteValueAMD64_OpConstBool(v *Value) bool {
+func rewriteValueAMD64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVLconst [b])
@@ -36022,7 +36237,7 @@
return true
}
}
-func rewriteValueAMD64_OpConstNil(v *Value) bool {
+func rewriteValueAMD64_OpConstNil_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -36051,7 +36266,7 @@
}
return false
}
-func rewriteValueAMD64_OpConvert(v *Value) bool {
+func rewriteValueAMD64_OpConvert_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -36090,7 +36305,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz32(v *Value) bool {
+func rewriteValueAMD64_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36112,7 +36327,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz64(v *Value) bool {
+func rewriteValueAMD64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36140,7 +36355,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CVTTSS2SL x)
@@ -36151,7 +36366,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (CVTTSS2SQ x)
@@ -36162,7 +36377,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (CVTSS2SD x)
@@ -36173,7 +36388,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CVTSL2SS x)
@@ -36184,7 +36399,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt32to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CVTSL2SD x)
@@ -36195,7 +36410,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CVTTSD2SL x)
@@ -36206,7 +36421,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (CVTSD2SS x)
@@ -36217,7 +36432,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (CVTTSD2SQ x)
@@ -36228,7 +36443,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (CVTSQ2SS x)
@@ -36239,7 +36454,7 @@
return true
}
}
-func rewriteValueAMD64_OpCvt64to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (CVTSQ2SD x)
@@ -36250,7 +36465,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv128u(v *Value) bool {
+func rewriteValueAMD64_OpDiv128u_0(v *Value) bool {
// match: (Div128u xhi xlo y)
// cond:
// result: (DIVQU2 xhi xlo y)
@@ -36265,7 +36480,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16(v *Value) bool {
+func rewriteValueAMD64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36284,7 +36499,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16u(v *Value) bool {
+func rewriteValueAMD64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36303,7 +36518,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32(v *Value) bool {
+func rewriteValueAMD64_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36322,7 +36537,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32F(v *Value) bool {
+func rewriteValueAMD64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVSS x y)
@@ -36335,7 +36550,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32u(v *Value) bool {
+func rewriteValueAMD64_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36354,7 +36569,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64(v *Value) bool {
+func rewriteValueAMD64_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36373,7 +36588,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64F(v *Value) bool {
+func rewriteValueAMD64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVSD x y)
@@ -36386,7 +36601,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64u(v *Value) bool {
+func rewriteValueAMD64_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36405,7 +36620,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8(v *Value) bool {
+func rewriteValueAMD64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36428,7 +36643,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8u(v *Value) bool {
+func rewriteValueAMD64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -36451,7 +36666,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq16(v *Value) bool {
+func rewriteValueAMD64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x y)
@@ -36468,7 +36683,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32(v *Value) bool {
+func rewriteValueAMD64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
@@ -36485,7 +36700,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32F(v *Value) bool {
+func rewriteValueAMD64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -36502,7 +36717,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64(v *Value) bool {
+func rewriteValueAMD64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
@@ -36519,7 +36734,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64F(v *Value) bool {
+func rewriteValueAMD64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -36536,7 +36751,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq8(v *Value) bool {
+func rewriteValueAMD64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x y)
@@ -36553,7 +36768,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqB(v *Value) bool {
+func rewriteValueAMD64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqB x y)
@@ -36570,7 +36785,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqPtr(v *Value) bool {
+func rewriteValueAMD64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -36609,7 +36824,7 @@
}
return false
}
-func rewriteValueAMD64_OpGeq16(v *Value) bool {
+func rewriteValueAMD64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16 x y)
@@ -36626,7 +36841,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq16U(v *Value) bool {
+func rewriteValueAMD64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16U x y)
@@ -36643,7 +36858,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32(v *Value) bool {
+func rewriteValueAMD64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
@@ -36660,7 +36875,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32F(v *Value) bool {
+func rewriteValueAMD64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -36677,7 +36892,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32U(v *Value) bool {
+func rewriteValueAMD64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
@@ -36694,7 +36909,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64(v *Value) bool {
+func rewriteValueAMD64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
@@ -36711,7 +36926,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64F(v *Value) bool {
+func rewriteValueAMD64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -36728,7 +36943,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64U(v *Value) bool {
+func rewriteValueAMD64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
@@ -36745,7 +36960,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq8(v *Value) bool {
+func rewriteValueAMD64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8 x y)
@@ -36762,7 +36977,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq8U(v *Value) bool {
+func rewriteValueAMD64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8U x y)
@@ -36779,7 +36994,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueAMD64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -36788,7 +37003,7 @@
return true
}
}
-func rewriteValueAMD64_OpGetG(v *Value) bool {
+func rewriteValueAMD64_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
@@ -36799,7 +37014,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater16(v *Value) bool {
+func rewriteValueAMD64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16 x y)
@@ -36816,7 +37031,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater16U(v *Value) bool {
+func rewriteValueAMD64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16U x y)
@@ -36833,7 +37048,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32(v *Value) bool {
+func rewriteValueAMD64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
@@ -36850,7 +37065,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32F(v *Value) bool {
+func rewriteValueAMD64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -36867,7 +37082,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32U(v *Value) bool {
+func rewriteValueAMD64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
@@ -36884,7 +37099,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64(v *Value) bool {
+func rewriteValueAMD64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
@@ -36901,7 +37116,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64F(v *Value) bool {
+func rewriteValueAMD64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -36918,7 +37133,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64U(v *Value) bool {
+func rewriteValueAMD64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
@@ -36935,7 +37150,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater8(v *Value) bool {
+func rewriteValueAMD64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8 x y)
@@ -36952,7 +37167,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater8U(v *Value) bool {
+func rewriteValueAMD64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8U x y)
@@ -36969,7 +37184,7 @@
return true
}
}
-func rewriteValueAMD64_OpHmul32(v *Value) bool {
+func rewriteValueAMD64_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMULL x y)
@@ -36982,7 +37197,7 @@
return true
}
}
-func rewriteValueAMD64_OpHmul32u(v *Value) bool {
+func rewriteValueAMD64_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULLU x y)
@@ -36995,7 +37210,7 @@
return true
}
}
-func rewriteValueAMD64_OpHmul64(v *Value) bool {
+func rewriteValueAMD64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (HMULQ x y)
@@ -37008,7 +37223,7 @@
return true
}
}
-func rewriteValueAMD64_OpHmul64u(v *Value) bool {
+func rewriteValueAMD64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (HMULQU x y)
@@ -37021,7 +37236,7 @@
return true
}
}
-func rewriteValueAMD64_OpInt64Hi(v *Value) bool {
+func rewriteValueAMD64_OpInt64Hi_0(v *Value) bool {
// match: (Int64Hi x)
// cond:
// result: (SHRQconst [32] x)
@@ -37033,7 +37248,7 @@
return true
}
}
-func rewriteValueAMD64_OpInterCall(v *Value) bool {
+func rewriteValueAMD64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -37048,7 +37263,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
@@ -37065,7 +37280,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNonNil(v *Value) bool {
+func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -37102,7 +37317,7 @@
}
return false
}
-func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
@@ -37119,7 +37334,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16(v *Value) bool {
+func rewriteValueAMD64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16 x y)
@@ -37136,7 +37351,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16U(v *Value) bool {
+func rewriteValueAMD64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16U x y)
@@ -37153,7 +37368,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32(v *Value) bool {
+func rewriteValueAMD64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
@@ -37170,7 +37385,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32F(v *Value) bool {
+func rewriteValueAMD64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -37187,7 +37402,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32U(v *Value) bool {
+func rewriteValueAMD64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
@@ -37204,7 +37419,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64(v *Value) bool {
+func rewriteValueAMD64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
@@ -37221,7 +37436,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64F(v *Value) bool {
+func rewriteValueAMD64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -37238,7 +37453,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64U(v *Value) bool {
+func rewriteValueAMD64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
@@ -37255,7 +37470,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8(v *Value) bool {
+func rewriteValueAMD64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8 x y)
@@ -37272,7 +37487,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8U(v *Value) bool {
+func rewriteValueAMD64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8U x y)
@@ -37289,7 +37504,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16(v *Value) bool {
+func rewriteValueAMD64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16 x y)
@@ -37306,7 +37521,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16U(v *Value) bool {
+func rewriteValueAMD64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16U x y)
@@ -37323,7 +37538,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32(v *Value) bool {
+func rewriteValueAMD64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
@@ -37340,7 +37555,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32F(v *Value) bool {
+func rewriteValueAMD64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -37357,7 +37572,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32U(v *Value) bool {
+func rewriteValueAMD64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
@@ -37374,7 +37589,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64(v *Value) bool {
+func rewriteValueAMD64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
@@ -37391,7 +37606,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64F(v *Value) bool {
+func rewriteValueAMD64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -37408,7 +37623,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64U(v *Value) bool {
+func rewriteValueAMD64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
@@ -37425,7 +37640,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8(v *Value) bool {
+func rewriteValueAMD64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8 x y)
@@ -37442,7 +37657,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8U(v *Value) bool {
+func rewriteValueAMD64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8U x y)
@@ -37459,7 +37674,7 @@
return true
}
}
-func rewriteValueAMD64_OpLoad(v *Value) bool {
+func rewriteValueAMD64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -37556,7 +37771,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x y)
@@ -37580,7 +37795,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
@@ -37604,7 +37819,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 <t> x y)
@@ -37628,7 +37843,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x y)
@@ -37652,7 +37867,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x y)
@@ -37676,7 +37891,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
@@ -37700,7 +37915,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 <t> x y)
@@ -37724,7 +37939,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x y)
@@ -37748,7 +37963,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x16 <t> x y)
@@ -37772,7 +37987,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x y)
@@ -37796,7 +38011,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 <t> x y)
@@ -37820,7 +38035,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x8 <t> x y)
@@ -37844,7 +38059,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x y)
@@ -37868,7 +38083,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
@@ -37892,7 +38107,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 <t> x y)
@@ -37916,7 +38131,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x y)
@@ -37940,7 +38155,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod16(v *Value) bool {
+func rewriteValueAMD64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -37959,7 +38174,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod16u(v *Value) bool {
+func rewriteValueAMD64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -37978,7 +38193,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32(v *Value) bool {
+func rewriteValueAMD64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -37997,7 +38212,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32u(v *Value) bool {
+func rewriteValueAMD64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38016,7 +38231,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64(v *Value) bool {
+func rewriteValueAMD64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38035,7 +38250,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64u(v *Value) bool {
+func rewriteValueAMD64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38054,7 +38269,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8(v *Value) bool {
+func rewriteValueAMD64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38077,7 +38292,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8u(v *Value) bool {
+func rewriteValueAMD64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38100,11 +38315,9 @@
return true
}
}
-func rewriteValueAMD64_OpMove(v *Value) bool {
+func rewriteValueAMD64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
@@ -38327,6 +38540,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [s] dst src mem)
// cond: s > 8 && s < 16
// result: (MOVQstore [s-8] dst (MOVQload [s-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
@@ -38458,7 +38680,7 @@
}
return false
}
-func rewriteValueAMD64_OpMul16(v *Value) bool {
+func rewriteValueAMD64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULL x y)
@@ -38471,7 +38693,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul32(v *Value) bool {
+func rewriteValueAMD64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULL x y)
@@ -38484,7 +38706,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul32F(v *Value) bool {
+func rewriteValueAMD64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULSS x y)
@@ -38497,7 +38719,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul64(v *Value) bool {
+func rewriteValueAMD64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULQ x y)
@@ -38510,7 +38732,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul64F(v *Value) bool {
+func rewriteValueAMD64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULSD x y)
@@ -38523,7 +38745,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul64uhilo(v *Value) bool {
+func rewriteValueAMD64_OpMul64uhilo_0(v *Value) bool {
// match: (Mul64uhilo x y)
// cond:
// result: (MULQU2 x y)
@@ -38536,7 +38758,7 @@
return true
}
}
-func rewriteValueAMD64_OpMul8(v *Value) bool {
+func rewriteValueAMD64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULL x y)
@@ -38549,7 +38771,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg16(v *Value) bool {
+func rewriteValueAMD64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGL x)
@@ -38560,7 +38782,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg32(v *Value) bool {
+func rewriteValueAMD64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGL x)
@@ -38571,7 +38793,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg32F(v *Value) bool {
+func rewriteValueAMD64_OpNeg32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38589,7 +38811,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg64(v *Value) bool {
+func rewriteValueAMD64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEGQ x)
@@ -38600,7 +38822,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg64F(v *Value) bool {
+func rewriteValueAMD64_OpNeg64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38618,7 +38840,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg8(v *Value) bool {
+func rewriteValueAMD64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGL x)
@@ -38629,7 +38851,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq16(v *Value) bool {
+func rewriteValueAMD64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x y)
@@ -38646,7 +38868,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32(v *Value) bool {
+func rewriteValueAMD64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
@@ -38663,7 +38885,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32F(v *Value) bool {
+func rewriteValueAMD64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -38680,7 +38902,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64(v *Value) bool {
+func rewriteValueAMD64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
@@ -38697,7 +38919,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64F(v *Value) bool {
+func rewriteValueAMD64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -38714,7 +38936,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq8(v *Value) bool {
+func rewriteValueAMD64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x y)
@@ -38731,7 +38953,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqB(v *Value) bool {
+func rewriteValueAMD64_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqB x y)
@@ -38748,7 +38970,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqPtr(v *Value) bool {
+func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -38787,7 +39009,7 @@
}
return false
}
-func rewriteValueAMD64_OpNilCheck(v *Value) bool {
+func rewriteValueAMD64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -38800,7 +39022,7 @@
return true
}
}
-func rewriteValueAMD64_OpNot(v *Value) bool {
+func rewriteValueAMD64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORLconst [1] x)
@@ -38812,7 +39034,7 @@
return true
}
}
-func rewriteValueAMD64_OpOffPtr(v *Value) bool {
+func rewriteValueAMD64_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -38865,7 +39087,7 @@
}
return false
}
-func rewriteValueAMD64_OpOr16(v *Value) bool {
+func rewriteValueAMD64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORL x y)
@@ -38878,7 +39100,7 @@
return true
}
}
-func rewriteValueAMD64_OpOr32(v *Value) bool {
+func rewriteValueAMD64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORL x y)
@@ -38891,7 +39113,7 @@
return true
}
}
-func rewriteValueAMD64_OpOr64(v *Value) bool {
+func rewriteValueAMD64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (ORQ x y)
@@ -38904,7 +39126,7 @@
return true
}
}
-func rewriteValueAMD64_OpOr8(v *Value) bool {
+func rewriteValueAMD64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORL x y)
@@ -38917,7 +39139,7 @@
return true
}
}
-func rewriteValueAMD64_OpOrB(v *Value) bool {
+func rewriteValueAMD64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORL x y)
@@ -38930,7 +39152,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount16(v *Value) bool {
+func rewriteValueAMD64_OpPopCount16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38947,7 +39169,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount32(v *Value) bool {
+func rewriteValueAMD64_OpPopCount32_0(v *Value) bool {
// match: (PopCount32 x)
// cond:
// result: (POPCNTL x)
@@ -38958,7 +39180,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount64(v *Value) bool {
+func rewriteValueAMD64_OpPopCount64_0(v *Value) bool {
// match: (PopCount64 x)
// cond:
// result: (POPCNTQ x)
@@ -38969,7 +39191,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount8(v *Value) bool {
+func rewriteValueAMD64_OpPopCount8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -38986,7 +39208,7 @@
return true
}
}
-func rewriteValueAMD64_OpRound32F(v *Value) bool {
+func rewriteValueAMD64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
@@ -38998,7 +39220,7 @@
return true
}
}
-func rewriteValueAMD64_OpRound64F(v *Value) bool {
+func rewriteValueAMD64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
@@ -39010,7 +39232,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x y)
@@ -39034,7 +39256,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x y)
@@ -39058,7 +39280,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux64 <t> x y)
@@ -39082,7 +39304,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x y)
@@ -39106,7 +39328,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x y)
@@ -39133,7 +39355,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x y)
@@ -39160,7 +39382,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x64 <t> x y)
@@ -39187,7 +39409,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x y)
@@ -39214,7 +39436,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x y)
@@ -39238,7 +39460,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
@@ -39262,7 +39484,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux64 <t> x y)
@@ -39286,7 +39508,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x y)
@@ -39310,7 +39532,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x y)
@@ -39337,7 +39559,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
@@ -39364,7 +39586,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x64 <t> x y)
@@ -39391,7 +39613,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x y)
@@ -39418,7 +39640,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux16 <t> x y)
@@ -39442,7 +39664,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x y)
@@ -39466,7 +39688,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 <t> x y)
@@ -39490,7 +39712,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux8 <t> x y)
@@ -39514,7 +39736,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x16 <t> x y)
@@ -39541,7 +39763,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x y)
@@ -39568,7 +39790,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 <t> x y)
@@ -39595,7 +39817,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x8 <t> x y)
@@ -39622,7 +39844,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x y)
@@ -39646,7 +39868,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x y)
@@ -39670,7 +39892,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux64 <t> x y)
@@ -39694,7 +39916,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x y)
@@ -39718,7 +39940,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x y)
@@ -39745,7 +39967,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x y)
@@ -39772,7 +39994,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x64 <t> x y)
@@ -39799,7 +40021,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x y)
@@ -39826,7 +40048,7 @@
return true
}
}
-func rewriteValueAMD64_OpSelect0(v *Value) bool {
+func rewriteValueAMD64_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
// match: (Select0 <t> (AddTupleFirst32 tuple val))
@@ -39867,7 +40089,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelect1(v *Value) bool {
+func rewriteValueAMD64_OpSelect1_0(v *Value) bool {
// match: (Select1 (AddTupleFirst32 tuple _))
// cond:
// result: (Select1 tuple)
@@ -39896,7 +40118,7 @@
}
return false
}
-func rewriteValueAMD64_OpSignExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVWQSX x)
@@ -39907,7 +40129,7 @@
return true
}
}
-func rewriteValueAMD64_OpSignExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVWQSX x)
@@ -39918,7 +40140,7 @@
return true
}
}
-func rewriteValueAMD64_OpSignExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVLQSX x)
@@ -39929,7 +40151,7 @@
return true
}
}
-func rewriteValueAMD64_OpSignExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBQSX x)
@@ -39940,7 +40162,7 @@
return true
}
}
-func rewriteValueAMD64_OpSignExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBQSX x)
@@ -39951,7 +40173,7 @@
return true
}
}
-func rewriteValueAMD64_OpSignExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBQSX x)
@@ -39962,7 +40184,7 @@
return true
}
}
-func rewriteValueAMD64_OpSlicemask(v *Value) bool {
+func rewriteValueAMD64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -39979,7 +40201,7 @@
return true
}
}
-func rewriteValueAMD64_OpSqrt(v *Value) bool {
+func rewriteValueAMD64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTSD x)
@@ -39990,7 +40212,7 @@
return true
}
}
-func rewriteValueAMD64_OpStaticCall(v *Value) bool {
+func rewriteValueAMD64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -40005,7 +40227,7 @@
return true
}
}
-func rewriteValueAMD64_OpStore(v *Value) bool {
+func rewriteValueAMD64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
@@ -40110,7 +40332,7 @@
}
return false
}
-func rewriteValueAMD64_OpSub16(v *Value) bool {
+func rewriteValueAMD64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBL x y)
@@ -40123,7 +40345,7 @@
return true
}
}
-func rewriteValueAMD64_OpSub32(v *Value) bool {
+func rewriteValueAMD64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBL x y)
@@ -40136,7 +40358,7 @@
return true
}
}
-func rewriteValueAMD64_OpSub32F(v *Value) bool {
+func rewriteValueAMD64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBSS x y)
@@ -40149,7 +40371,7 @@
return true
}
}
-func rewriteValueAMD64_OpSub64(v *Value) bool {
+func rewriteValueAMD64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUBQ x y)
@@ -40162,7 +40384,7 @@
return true
}
}
-func rewriteValueAMD64_OpSub64F(v *Value) bool {
+func rewriteValueAMD64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBSD x y)
@@ -40175,7 +40397,7 @@
return true
}
}
-func rewriteValueAMD64_OpSub8(v *Value) bool {
+func rewriteValueAMD64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBL x y)
@@ -40188,7 +40410,7 @@
return true
}
}
-func rewriteValueAMD64_OpSubPtr(v *Value) bool {
+func rewriteValueAMD64_OpSubPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -40223,7 +40445,7 @@
}
return false
}
-func rewriteValueAMD64_OpTrunc16to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -40235,7 +40457,7 @@
return true
}
}
-func rewriteValueAMD64_OpTrunc32to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -40247,7 +40469,7 @@
return true
}
}
-func rewriteValueAMD64_OpTrunc32to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -40259,7 +40481,7 @@
return true
}
}
-func rewriteValueAMD64_OpTrunc64to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
@@ -40271,7 +40493,7 @@
return true
}
}
-func rewriteValueAMD64_OpTrunc64to32(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
@@ -40283,7 +40505,7 @@
return true
}
}
-func rewriteValueAMD64_OpTrunc64to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
@@ -40295,7 +40517,7 @@
return true
}
}
-func rewriteValueAMD64_OpXor16(v *Value) bool {
+func rewriteValueAMD64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORL x y)
@@ -40308,7 +40530,7 @@
return true
}
}
-func rewriteValueAMD64_OpXor32(v *Value) bool {
+func rewriteValueAMD64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORL x y)
@@ -40321,7 +40543,7 @@
return true
}
}
-func rewriteValueAMD64_OpXor64(v *Value) bool {
+func rewriteValueAMD64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XORQ x y)
@@ -40334,7 +40556,7 @@
return true
}
}
-func rewriteValueAMD64_OpXor8(v *Value) bool {
+func rewriteValueAMD64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORL x y)
@@ -40347,13 +40569,9 @@
return true
}
}
-func rewriteValueAMD64_OpZero(v *Value) bool {
+func rewriteValueAMD64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
- types := &b.Func.Config.Types
- _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
@@ -40526,6 +40744,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [16] destptr mem)
// cond:
// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
@@ -40662,7 +40889,7 @@
}
return false
}
-func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVWQZX x)
@@ -40673,7 +40900,7 @@
return true
}
}
-func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVWQZX x)
@@ -40684,7 +40911,7 @@
return true
}
}
-func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVLQZX x)
@@ -40695,7 +40922,7 @@
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBQZX x)
@@ -40706,7 +40933,7 @@
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBQZX x)
@@ -40717,7 +40944,7 @@
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBQZX x)
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 944093a..1176969 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -14,721 +14,721 @@
func rewriteValueARM(v *Value) bool {
switch v.Op {
case OpARMADC:
- return rewriteValueARM_OpARMADC(v)
+ return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v)
case OpARMADCconst:
- return rewriteValueARM_OpARMADCconst(v)
+ return rewriteValueARM_OpARMADCconst_0(v)
case OpARMADCshiftLL:
- return rewriteValueARM_OpARMADCshiftLL(v)
+ return rewriteValueARM_OpARMADCshiftLL_0(v)
case OpARMADCshiftLLreg:
- return rewriteValueARM_OpARMADCshiftLLreg(v)
+ return rewriteValueARM_OpARMADCshiftLLreg_0(v)
case OpARMADCshiftRA:
- return rewriteValueARM_OpARMADCshiftRA(v)
+ return rewriteValueARM_OpARMADCshiftRA_0(v)
case OpARMADCshiftRAreg:
- return rewriteValueARM_OpARMADCshiftRAreg(v)
+ return rewriteValueARM_OpARMADCshiftRAreg_0(v)
case OpARMADCshiftRL:
- return rewriteValueARM_OpARMADCshiftRL(v)
+ return rewriteValueARM_OpARMADCshiftRL_0(v)
case OpARMADCshiftRLreg:
- return rewriteValueARM_OpARMADCshiftRLreg(v)
+ return rewriteValueARM_OpARMADCshiftRLreg_0(v)
case OpARMADD:
- return rewriteValueARM_OpARMADD(v)
+ return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v)
case OpARMADDS:
- return rewriteValueARM_OpARMADDS(v)
+ return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v)
case OpARMADDSshiftLL:
- return rewriteValueARM_OpARMADDSshiftLL(v)
+ return rewriteValueARM_OpARMADDSshiftLL_0(v)
case OpARMADDSshiftLLreg:
- return rewriteValueARM_OpARMADDSshiftLLreg(v)
+ return rewriteValueARM_OpARMADDSshiftLLreg_0(v)
case OpARMADDSshiftRA:
- return rewriteValueARM_OpARMADDSshiftRA(v)
+ return rewriteValueARM_OpARMADDSshiftRA_0(v)
case OpARMADDSshiftRAreg:
- return rewriteValueARM_OpARMADDSshiftRAreg(v)
+ return rewriteValueARM_OpARMADDSshiftRAreg_0(v)
case OpARMADDSshiftRL:
- return rewriteValueARM_OpARMADDSshiftRL(v)
+ return rewriteValueARM_OpARMADDSshiftRL_0(v)
case OpARMADDSshiftRLreg:
- return rewriteValueARM_OpARMADDSshiftRLreg(v)
+ return rewriteValueARM_OpARMADDSshiftRLreg_0(v)
case OpARMADDconst:
- return rewriteValueARM_OpARMADDconst(v)
+ return rewriteValueARM_OpARMADDconst_0(v)
case OpARMADDshiftLL:
- return rewriteValueARM_OpARMADDshiftLL(v)
+ return rewriteValueARM_OpARMADDshiftLL_0(v)
case OpARMADDshiftLLreg:
- return rewriteValueARM_OpARMADDshiftLLreg(v)
+ return rewriteValueARM_OpARMADDshiftLLreg_0(v)
case OpARMADDshiftRA:
- return rewriteValueARM_OpARMADDshiftRA(v)
+ return rewriteValueARM_OpARMADDshiftRA_0(v)
case OpARMADDshiftRAreg:
- return rewriteValueARM_OpARMADDshiftRAreg(v)
+ return rewriteValueARM_OpARMADDshiftRAreg_0(v)
case OpARMADDshiftRL:
- return rewriteValueARM_OpARMADDshiftRL(v)
+ return rewriteValueARM_OpARMADDshiftRL_0(v)
case OpARMADDshiftRLreg:
- return rewriteValueARM_OpARMADDshiftRLreg(v)
+ return rewriteValueARM_OpARMADDshiftRLreg_0(v)
case OpARMAND:
- return rewriteValueARM_OpARMAND(v)
+ return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v)
case OpARMANDconst:
- return rewriteValueARM_OpARMANDconst(v)
+ return rewriteValueARM_OpARMANDconst_0(v)
case OpARMANDshiftLL:
- return rewriteValueARM_OpARMANDshiftLL(v)
+ return rewriteValueARM_OpARMANDshiftLL_0(v)
case OpARMANDshiftLLreg:
- return rewriteValueARM_OpARMANDshiftLLreg(v)
+ return rewriteValueARM_OpARMANDshiftLLreg_0(v)
case OpARMANDshiftRA:
- return rewriteValueARM_OpARMANDshiftRA(v)
+ return rewriteValueARM_OpARMANDshiftRA_0(v)
case OpARMANDshiftRAreg:
- return rewriteValueARM_OpARMANDshiftRAreg(v)
+ return rewriteValueARM_OpARMANDshiftRAreg_0(v)
case OpARMANDshiftRL:
- return rewriteValueARM_OpARMANDshiftRL(v)
+ return rewriteValueARM_OpARMANDshiftRL_0(v)
case OpARMANDshiftRLreg:
- return rewriteValueARM_OpARMANDshiftRLreg(v)
+ return rewriteValueARM_OpARMANDshiftRLreg_0(v)
case OpARMBIC:
- return rewriteValueARM_OpARMBIC(v)
+ return rewriteValueARM_OpARMBIC_0(v)
case OpARMBICconst:
- return rewriteValueARM_OpARMBICconst(v)
+ return rewriteValueARM_OpARMBICconst_0(v)
case OpARMBICshiftLL:
- return rewriteValueARM_OpARMBICshiftLL(v)
+ return rewriteValueARM_OpARMBICshiftLL_0(v)
case OpARMBICshiftLLreg:
- return rewriteValueARM_OpARMBICshiftLLreg(v)
+ return rewriteValueARM_OpARMBICshiftLLreg_0(v)
case OpARMBICshiftRA:
- return rewriteValueARM_OpARMBICshiftRA(v)
+ return rewriteValueARM_OpARMBICshiftRA_0(v)
case OpARMBICshiftRAreg:
- return rewriteValueARM_OpARMBICshiftRAreg(v)
+ return rewriteValueARM_OpARMBICshiftRAreg_0(v)
case OpARMBICshiftRL:
- return rewriteValueARM_OpARMBICshiftRL(v)
+ return rewriteValueARM_OpARMBICshiftRL_0(v)
case OpARMBICshiftRLreg:
- return rewriteValueARM_OpARMBICshiftRLreg(v)
+ return rewriteValueARM_OpARMBICshiftRLreg_0(v)
case OpARMCMOVWHSconst:
- return rewriteValueARM_OpARMCMOVWHSconst(v)
+ return rewriteValueARM_OpARMCMOVWHSconst_0(v)
case OpARMCMOVWLSconst:
- return rewriteValueARM_OpARMCMOVWLSconst(v)
+ return rewriteValueARM_OpARMCMOVWLSconst_0(v)
case OpARMCMP:
- return rewriteValueARM_OpARMCMP(v)
+ return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v)
case OpARMCMPD:
- return rewriteValueARM_OpARMCMPD(v)
+ return rewriteValueARM_OpARMCMPD_0(v)
case OpARMCMPF:
- return rewriteValueARM_OpARMCMPF(v)
+ return rewriteValueARM_OpARMCMPF_0(v)
case OpARMCMPconst:
- return rewriteValueARM_OpARMCMPconst(v)
+ return rewriteValueARM_OpARMCMPconst_0(v)
case OpARMCMPshiftLL:
- return rewriteValueARM_OpARMCMPshiftLL(v)
+ return rewriteValueARM_OpARMCMPshiftLL_0(v)
case OpARMCMPshiftLLreg:
- return rewriteValueARM_OpARMCMPshiftLLreg(v)
+ return rewriteValueARM_OpARMCMPshiftLLreg_0(v)
case OpARMCMPshiftRA:
- return rewriteValueARM_OpARMCMPshiftRA(v)
+ return rewriteValueARM_OpARMCMPshiftRA_0(v)
case OpARMCMPshiftRAreg:
- return rewriteValueARM_OpARMCMPshiftRAreg(v)
+ return rewriteValueARM_OpARMCMPshiftRAreg_0(v)
case OpARMCMPshiftRL:
- return rewriteValueARM_OpARMCMPshiftRL(v)
+ return rewriteValueARM_OpARMCMPshiftRL_0(v)
case OpARMCMPshiftRLreg:
- return rewriteValueARM_OpARMCMPshiftRLreg(v)
+ return rewriteValueARM_OpARMCMPshiftRLreg_0(v)
case OpARMEqual:
- return rewriteValueARM_OpARMEqual(v)
+ return rewriteValueARM_OpARMEqual_0(v)
case OpARMGreaterEqual:
- return rewriteValueARM_OpARMGreaterEqual(v)
+ return rewriteValueARM_OpARMGreaterEqual_0(v)
case OpARMGreaterEqualU:
- return rewriteValueARM_OpARMGreaterEqualU(v)
+ return rewriteValueARM_OpARMGreaterEqualU_0(v)
case OpARMGreaterThan:
- return rewriteValueARM_OpARMGreaterThan(v)
+ return rewriteValueARM_OpARMGreaterThan_0(v)
case OpARMGreaterThanU:
- return rewriteValueARM_OpARMGreaterThanU(v)
+ return rewriteValueARM_OpARMGreaterThanU_0(v)
case OpARMLessEqual:
- return rewriteValueARM_OpARMLessEqual(v)
+ return rewriteValueARM_OpARMLessEqual_0(v)
case OpARMLessEqualU:
- return rewriteValueARM_OpARMLessEqualU(v)
+ return rewriteValueARM_OpARMLessEqualU_0(v)
case OpARMLessThan:
- return rewriteValueARM_OpARMLessThan(v)
+ return rewriteValueARM_OpARMLessThan_0(v)
case OpARMLessThanU:
- return rewriteValueARM_OpARMLessThanU(v)
+ return rewriteValueARM_OpARMLessThanU_0(v)
case OpARMMOVBUload:
- return rewriteValueARM_OpARMMOVBUload(v)
+ return rewriteValueARM_OpARMMOVBUload_0(v)
case OpARMMOVBUreg:
- return rewriteValueARM_OpARMMOVBUreg(v)
+ return rewriteValueARM_OpARMMOVBUreg_0(v)
case OpARMMOVBload:
- return rewriteValueARM_OpARMMOVBload(v)
+ return rewriteValueARM_OpARMMOVBload_0(v)
case OpARMMOVBreg:
- return rewriteValueARM_OpARMMOVBreg(v)
+ return rewriteValueARM_OpARMMOVBreg_0(v)
case OpARMMOVBstore:
- return rewriteValueARM_OpARMMOVBstore(v)
+ return rewriteValueARM_OpARMMOVBstore_0(v)
case OpARMMOVDload:
- return rewriteValueARM_OpARMMOVDload(v)
+ return rewriteValueARM_OpARMMOVDload_0(v)
case OpARMMOVDstore:
- return rewriteValueARM_OpARMMOVDstore(v)
+ return rewriteValueARM_OpARMMOVDstore_0(v)
case OpARMMOVFload:
- return rewriteValueARM_OpARMMOVFload(v)
+ return rewriteValueARM_OpARMMOVFload_0(v)
case OpARMMOVFstore:
- return rewriteValueARM_OpARMMOVFstore(v)
+ return rewriteValueARM_OpARMMOVFstore_0(v)
case OpARMMOVHUload:
- return rewriteValueARM_OpARMMOVHUload(v)
+ return rewriteValueARM_OpARMMOVHUload_0(v)
case OpARMMOVHUreg:
- return rewriteValueARM_OpARMMOVHUreg(v)
+ return rewriteValueARM_OpARMMOVHUreg_0(v)
case OpARMMOVHload:
- return rewriteValueARM_OpARMMOVHload(v)
+ return rewriteValueARM_OpARMMOVHload_0(v)
case OpARMMOVHreg:
- return rewriteValueARM_OpARMMOVHreg(v)
+ return rewriteValueARM_OpARMMOVHreg_0(v)
case OpARMMOVHstore:
- return rewriteValueARM_OpARMMOVHstore(v)
+ return rewriteValueARM_OpARMMOVHstore_0(v)
case OpARMMOVWload:
- return rewriteValueARM_OpARMMOVWload(v)
+ return rewriteValueARM_OpARMMOVWload_0(v)
case OpARMMOVWloadidx:
- return rewriteValueARM_OpARMMOVWloadidx(v)
+ return rewriteValueARM_OpARMMOVWloadidx_0(v)
case OpARMMOVWloadshiftLL:
- return rewriteValueARM_OpARMMOVWloadshiftLL(v)
+ return rewriteValueARM_OpARMMOVWloadshiftLL_0(v)
case OpARMMOVWloadshiftRA:
- return rewriteValueARM_OpARMMOVWloadshiftRA(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRA_0(v)
case OpARMMOVWloadshiftRL:
- return rewriteValueARM_OpARMMOVWloadshiftRL(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRL_0(v)
case OpARMMOVWreg:
- return rewriteValueARM_OpARMMOVWreg(v)
+ return rewriteValueARM_OpARMMOVWreg_0(v)
case OpARMMOVWstore:
- return rewriteValueARM_OpARMMOVWstore(v)
+ return rewriteValueARM_OpARMMOVWstore_0(v)
case OpARMMOVWstoreidx:
- return rewriteValueARM_OpARMMOVWstoreidx(v)
+ return rewriteValueARM_OpARMMOVWstoreidx_0(v)
case OpARMMOVWstoreshiftLL:
- return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v)
case OpARMMOVWstoreshiftRA:
- return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v)
case OpARMMOVWstoreshiftRL:
- return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v)
case OpARMMUL:
- return rewriteValueARM_OpARMMUL(v)
+ return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v)
case OpARMMULA:
- return rewriteValueARM_OpARMMULA(v)
+ return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v)
case OpARMMVN:
- return rewriteValueARM_OpARMMVN(v)
+ return rewriteValueARM_OpARMMVN_0(v)
case OpARMMVNshiftLL:
- return rewriteValueARM_OpARMMVNshiftLL(v)
+ return rewriteValueARM_OpARMMVNshiftLL_0(v)
case OpARMMVNshiftLLreg:
- return rewriteValueARM_OpARMMVNshiftLLreg(v)
+ return rewriteValueARM_OpARMMVNshiftLLreg_0(v)
case OpARMMVNshiftRA:
- return rewriteValueARM_OpARMMVNshiftRA(v)
+ return rewriteValueARM_OpARMMVNshiftRA_0(v)
case OpARMMVNshiftRAreg:
- return rewriteValueARM_OpARMMVNshiftRAreg(v)
+ return rewriteValueARM_OpARMMVNshiftRAreg_0(v)
case OpARMMVNshiftRL:
- return rewriteValueARM_OpARMMVNshiftRL(v)
+ return rewriteValueARM_OpARMMVNshiftRL_0(v)
case OpARMMVNshiftRLreg:
- return rewriteValueARM_OpARMMVNshiftRLreg(v)
+ return rewriteValueARM_OpARMMVNshiftRLreg_0(v)
case OpARMNotEqual:
- return rewriteValueARM_OpARMNotEqual(v)
+ return rewriteValueARM_OpARMNotEqual_0(v)
case OpARMOR:
- return rewriteValueARM_OpARMOR(v)
+ return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v)
case OpARMORconst:
- return rewriteValueARM_OpARMORconst(v)
+ return rewriteValueARM_OpARMORconst_0(v)
case OpARMORshiftLL:
- return rewriteValueARM_OpARMORshiftLL(v)
+ return rewriteValueARM_OpARMORshiftLL_0(v)
case OpARMORshiftLLreg:
- return rewriteValueARM_OpARMORshiftLLreg(v)
+ return rewriteValueARM_OpARMORshiftLLreg_0(v)
case OpARMORshiftRA:
- return rewriteValueARM_OpARMORshiftRA(v)
+ return rewriteValueARM_OpARMORshiftRA_0(v)
case OpARMORshiftRAreg:
- return rewriteValueARM_OpARMORshiftRAreg(v)
+ return rewriteValueARM_OpARMORshiftRAreg_0(v)
case OpARMORshiftRL:
- return rewriteValueARM_OpARMORshiftRL(v)
+ return rewriteValueARM_OpARMORshiftRL_0(v)
case OpARMORshiftRLreg:
- return rewriteValueARM_OpARMORshiftRLreg(v)
+ return rewriteValueARM_OpARMORshiftRLreg_0(v)
case OpARMRSB:
- return rewriteValueARM_OpARMRSB(v)
+ return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v)
case OpARMRSBSshiftLL:
- return rewriteValueARM_OpARMRSBSshiftLL(v)
+ return rewriteValueARM_OpARMRSBSshiftLL_0(v)
case OpARMRSBSshiftLLreg:
- return rewriteValueARM_OpARMRSBSshiftLLreg(v)
+ return rewriteValueARM_OpARMRSBSshiftLLreg_0(v)
case OpARMRSBSshiftRA:
- return rewriteValueARM_OpARMRSBSshiftRA(v)
+ return rewriteValueARM_OpARMRSBSshiftRA_0(v)
case OpARMRSBSshiftRAreg:
- return rewriteValueARM_OpARMRSBSshiftRAreg(v)
+ return rewriteValueARM_OpARMRSBSshiftRAreg_0(v)
case OpARMRSBSshiftRL:
- return rewriteValueARM_OpARMRSBSshiftRL(v)
+ return rewriteValueARM_OpARMRSBSshiftRL_0(v)
case OpARMRSBSshiftRLreg:
- return rewriteValueARM_OpARMRSBSshiftRLreg(v)
+ return rewriteValueARM_OpARMRSBSshiftRLreg_0(v)
case OpARMRSBconst:
- return rewriteValueARM_OpARMRSBconst(v)
+ return rewriteValueARM_OpARMRSBconst_0(v)
case OpARMRSBshiftLL:
- return rewriteValueARM_OpARMRSBshiftLL(v)
+ return rewriteValueARM_OpARMRSBshiftLL_0(v)
case OpARMRSBshiftLLreg:
- return rewriteValueARM_OpARMRSBshiftLLreg(v)
+ return rewriteValueARM_OpARMRSBshiftLLreg_0(v)
case OpARMRSBshiftRA:
- return rewriteValueARM_OpARMRSBshiftRA(v)
+ return rewriteValueARM_OpARMRSBshiftRA_0(v)
case OpARMRSBshiftRAreg:
- return rewriteValueARM_OpARMRSBshiftRAreg(v)
+ return rewriteValueARM_OpARMRSBshiftRAreg_0(v)
case OpARMRSBshiftRL:
- return rewriteValueARM_OpARMRSBshiftRL(v)
+ return rewriteValueARM_OpARMRSBshiftRL_0(v)
case OpARMRSBshiftRLreg:
- return rewriteValueARM_OpARMRSBshiftRLreg(v)
+ return rewriteValueARM_OpARMRSBshiftRLreg_0(v)
case OpARMRSCconst:
- return rewriteValueARM_OpARMRSCconst(v)
+ return rewriteValueARM_OpARMRSCconst_0(v)
case OpARMRSCshiftLL:
- return rewriteValueARM_OpARMRSCshiftLL(v)
+ return rewriteValueARM_OpARMRSCshiftLL_0(v)
case OpARMRSCshiftLLreg:
- return rewriteValueARM_OpARMRSCshiftLLreg(v)
+ return rewriteValueARM_OpARMRSCshiftLLreg_0(v)
case OpARMRSCshiftRA:
- return rewriteValueARM_OpARMRSCshiftRA(v)
+ return rewriteValueARM_OpARMRSCshiftRA_0(v)
case OpARMRSCshiftRAreg:
- return rewriteValueARM_OpARMRSCshiftRAreg(v)
+ return rewriteValueARM_OpARMRSCshiftRAreg_0(v)
case OpARMRSCshiftRL:
- return rewriteValueARM_OpARMRSCshiftRL(v)
+ return rewriteValueARM_OpARMRSCshiftRL_0(v)
case OpARMRSCshiftRLreg:
- return rewriteValueARM_OpARMRSCshiftRLreg(v)
+ return rewriteValueARM_OpARMRSCshiftRLreg_0(v)
case OpARMSBC:
- return rewriteValueARM_OpARMSBC(v)
+ return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v)
case OpARMSBCconst:
- return rewriteValueARM_OpARMSBCconst(v)
+ return rewriteValueARM_OpARMSBCconst_0(v)
case OpARMSBCshiftLL:
- return rewriteValueARM_OpARMSBCshiftLL(v)
+ return rewriteValueARM_OpARMSBCshiftLL_0(v)
case OpARMSBCshiftLLreg:
- return rewriteValueARM_OpARMSBCshiftLLreg(v)
+ return rewriteValueARM_OpARMSBCshiftLLreg_0(v)
case OpARMSBCshiftRA:
- return rewriteValueARM_OpARMSBCshiftRA(v)
+ return rewriteValueARM_OpARMSBCshiftRA_0(v)
case OpARMSBCshiftRAreg:
- return rewriteValueARM_OpARMSBCshiftRAreg(v)
+ return rewriteValueARM_OpARMSBCshiftRAreg_0(v)
case OpARMSBCshiftRL:
- return rewriteValueARM_OpARMSBCshiftRL(v)
+ return rewriteValueARM_OpARMSBCshiftRL_0(v)
case OpARMSBCshiftRLreg:
- return rewriteValueARM_OpARMSBCshiftRLreg(v)
+ return rewriteValueARM_OpARMSBCshiftRLreg_0(v)
case OpARMSLL:
- return rewriteValueARM_OpARMSLL(v)
+ return rewriteValueARM_OpARMSLL_0(v)
case OpARMSLLconst:
- return rewriteValueARM_OpARMSLLconst(v)
+ return rewriteValueARM_OpARMSLLconst_0(v)
case OpARMSRA:
- return rewriteValueARM_OpARMSRA(v)
+ return rewriteValueARM_OpARMSRA_0(v)
case OpARMSRAcond:
- return rewriteValueARM_OpARMSRAcond(v)
+ return rewriteValueARM_OpARMSRAcond_0(v)
case OpARMSRAconst:
- return rewriteValueARM_OpARMSRAconst(v)
+ return rewriteValueARM_OpARMSRAconst_0(v)
case OpARMSRL:
- return rewriteValueARM_OpARMSRL(v)
+ return rewriteValueARM_OpARMSRL_0(v)
case OpARMSRLconst:
- return rewriteValueARM_OpARMSRLconst(v)
+ return rewriteValueARM_OpARMSRLconst_0(v)
case OpARMSUB:
- return rewriteValueARM_OpARMSUB(v)
+ return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v)
case OpARMSUBS:
- return rewriteValueARM_OpARMSUBS(v)
+ return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v)
case OpARMSUBSshiftLL:
- return rewriteValueARM_OpARMSUBSshiftLL(v)
+ return rewriteValueARM_OpARMSUBSshiftLL_0(v)
case OpARMSUBSshiftLLreg:
- return rewriteValueARM_OpARMSUBSshiftLLreg(v)
+ return rewriteValueARM_OpARMSUBSshiftLLreg_0(v)
case OpARMSUBSshiftRA:
- return rewriteValueARM_OpARMSUBSshiftRA(v)
+ return rewriteValueARM_OpARMSUBSshiftRA_0(v)
case OpARMSUBSshiftRAreg:
- return rewriteValueARM_OpARMSUBSshiftRAreg(v)
+ return rewriteValueARM_OpARMSUBSshiftRAreg_0(v)
case OpARMSUBSshiftRL:
- return rewriteValueARM_OpARMSUBSshiftRL(v)
+ return rewriteValueARM_OpARMSUBSshiftRL_0(v)
case OpARMSUBSshiftRLreg:
- return rewriteValueARM_OpARMSUBSshiftRLreg(v)
+ return rewriteValueARM_OpARMSUBSshiftRLreg_0(v)
case OpARMSUBconst:
- return rewriteValueARM_OpARMSUBconst(v)
+ return rewriteValueARM_OpARMSUBconst_0(v)
case OpARMSUBshiftLL:
- return rewriteValueARM_OpARMSUBshiftLL(v)
+ return rewriteValueARM_OpARMSUBshiftLL_0(v)
case OpARMSUBshiftLLreg:
- return rewriteValueARM_OpARMSUBshiftLLreg(v)
+ return rewriteValueARM_OpARMSUBshiftLLreg_0(v)
case OpARMSUBshiftRA:
- return rewriteValueARM_OpARMSUBshiftRA(v)
+ return rewriteValueARM_OpARMSUBshiftRA_0(v)
case OpARMSUBshiftRAreg:
- return rewriteValueARM_OpARMSUBshiftRAreg(v)
+ return rewriteValueARM_OpARMSUBshiftRAreg_0(v)
case OpARMSUBshiftRL:
- return rewriteValueARM_OpARMSUBshiftRL(v)
+ return rewriteValueARM_OpARMSUBshiftRL_0(v)
case OpARMSUBshiftRLreg:
- return rewriteValueARM_OpARMSUBshiftRLreg(v)
+ return rewriteValueARM_OpARMSUBshiftRLreg_0(v)
case OpARMXOR:
- return rewriteValueARM_OpARMXOR(v)
+ return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v)
case OpARMXORconst:
- return rewriteValueARM_OpARMXORconst(v)
+ return rewriteValueARM_OpARMXORconst_0(v)
case OpARMXORshiftLL:
- return rewriteValueARM_OpARMXORshiftLL(v)
+ return rewriteValueARM_OpARMXORshiftLL_0(v)
case OpARMXORshiftLLreg:
- return rewriteValueARM_OpARMXORshiftLLreg(v)
+ return rewriteValueARM_OpARMXORshiftLLreg_0(v)
case OpARMXORshiftRA:
- return rewriteValueARM_OpARMXORshiftRA(v)
+ return rewriteValueARM_OpARMXORshiftRA_0(v)
case OpARMXORshiftRAreg:
- return rewriteValueARM_OpARMXORshiftRAreg(v)
+ return rewriteValueARM_OpARMXORshiftRAreg_0(v)
case OpARMXORshiftRL:
- return rewriteValueARM_OpARMXORshiftRL(v)
+ return rewriteValueARM_OpARMXORshiftRL_0(v)
case OpARMXORshiftRLreg:
- return rewriteValueARM_OpARMXORshiftRLreg(v)
+ return rewriteValueARM_OpARMXORshiftRLreg_0(v)
case OpARMXORshiftRR:
- return rewriteValueARM_OpARMXORshiftRR(v)
+ return rewriteValueARM_OpARMXORshiftRR_0(v)
case OpAdd16:
- return rewriteValueARM_OpAdd16(v)
+ return rewriteValueARM_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueARM_OpAdd32(v)
+ return rewriteValueARM_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueARM_OpAdd32F(v)
+ return rewriteValueARM_OpAdd32F_0(v)
case OpAdd32carry:
- return rewriteValueARM_OpAdd32carry(v)
+ return rewriteValueARM_OpAdd32carry_0(v)
case OpAdd32withcarry:
- return rewriteValueARM_OpAdd32withcarry(v)
+ return rewriteValueARM_OpAdd32withcarry_0(v)
case OpAdd64F:
- return rewriteValueARM_OpAdd64F(v)
+ return rewriteValueARM_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueARM_OpAdd8(v)
+ return rewriteValueARM_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueARM_OpAddPtr(v)
+ return rewriteValueARM_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueARM_OpAddr(v)
+ return rewriteValueARM_OpAddr_0(v)
case OpAnd16:
- return rewriteValueARM_OpAnd16(v)
+ return rewriteValueARM_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueARM_OpAnd32(v)
+ return rewriteValueARM_OpAnd32_0(v)
case OpAnd8:
- return rewriteValueARM_OpAnd8(v)
+ return rewriteValueARM_OpAnd8_0(v)
case OpAndB:
- return rewriteValueARM_OpAndB(v)
+ return rewriteValueARM_OpAndB_0(v)
case OpAvg32u:
- return rewriteValueARM_OpAvg32u(v)
+ return rewriteValueARM_OpAvg32u_0(v)
case OpBitLen32:
- return rewriteValueARM_OpBitLen32(v)
+ return rewriteValueARM_OpBitLen32_0(v)
case OpBswap32:
- return rewriteValueARM_OpBswap32(v)
+ return rewriteValueARM_OpBswap32_0(v)
case OpClosureCall:
- return rewriteValueARM_OpClosureCall(v)
+ return rewriteValueARM_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueARM_OpCom16(v)
+ return rewriteValueARM_OpCom16_0(v)
case OpCom32:
- return rewriteValueARM_OpCom32(v)
+ return rewriteValueARM_OpCom32_0(v)
case OpCom8:
- return rewriteValueARM_OpCom8(v)
+ return rewriteValueARM_OpCom8_0(v)
case OpConst16:
- return rewriteValueARM_OpConst16(v)
+ return rewriteValueARM_OpConst16_0(v)
case OpConst32:
- return rewriteValueARM_OpConst32(v)
+ return rewriteValueARM_OpConst32_0(v)
case OpConst32F:
- return rewriteValueARM_OpConst32F(v)
+ return rewriteValueARM_OpConst32F_0(v)
case OpConst64F:
- return rewriteValueARM_OpConst64F(v)
+ return rewriteValueARM_OpConst64F_0(v)
case OpConst8:
- return rewriteValueARM_OpConst8(v)
+ return rewriteValueARM_OpConst8_0(v)
case OpConstBool:
- return rewriteValueARM_OpConstBool(v)
+ return rewriteValueARM_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueARM_OpConstNil(v)
+ return rewriteValueARM_OpConstNil_0(v)
case OpConvert:
- return rewriteValueARM_OpConvert(v)
+ return rewriteValueARM_OpConvert_0(v)
case OpCtz32:
- return rewriteValueARM_OpCtz32(v)
+ return rewriteValueARM_OpCtz32_0(v)
case OpCvt32Fto32:
- return rewriteValueARM_OpCvt32Fto32(v)
+ return rewriteValueARM_OpCvt32Fto32_0(v)
case OpCvt32Fto32U:
- return rewriteValueARM_OpCvt32Fto32U(v)
+ return rewriteValueARM_OpCvt32Fto32U_0(v)
case OpCvt32Fto64F:
- return rewriteValueARM_OpCvt32Fto64F(v)
+ return rewriteValueARM_OpCvt32Fto64F_0(v)
case OpCvt32Uto32F:
- return rewriteValueARM_OpCvt32Uto32F(v)
+ return rewriteValueARM_OpCvt32Uto32F_0(v)
case OpCvt32Uto64F:
- return rewriteValueARM_OpCvt32Uto64F(v)
+ return rewriteValueARM_OpCvt32Uto64F_0(v)
case OpCvt32to32F:
- return rewriteValueARM_OpCvt32to32F(v)
+ return rewriteValueARM_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueARM_OpCvt32to64F(v)
+ return rewriteValueARM_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueARM_OpCvt64Fto32(v)
+ return rewriteValueARM_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueARM_OpCvt64Fto32F(v)
+ return rewriteValueARM_OpCvt64Fto32F_0(v)
case OpCvt64Fto32U:
- return rewriteValueARM_OpCvt64Fto32U(v)
+ return rewriteValueARM_OpCvt64Fto32U_0(v)
case OpDiv16:
- return rewriteValueARM_OpDiv16(v)
+ return rewriteValueARM_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueARM_OpDiv16u(v)
+ return rewriteValueARM_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueARM_OpDiv32(v)
+ return rewriteValueARM_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueARM_OpDiv32F(v)
+ return rewriteValueARM_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueARM_OpDiv32u(v)
+ return rewriteValueARM_OpDiv32u_0(v)
case OpDiv64F:
- return rewriteValueARM_OpDiv64F(v)
+ return rewriteValueARM_OpDiv64F_0(v)
case OpDiv8:
- return rewriteValueARM_OpDiv8(v)
+ return rewriteValueARM_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueARM_OpDiv8u(v)
+ return rewriteValueARM_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueARM_OpEq16(v)
+ return rewriteValueARM_OpEq16_0(v)
case OpEq32:
- return rewriteValueARM_OpEq32(v)
+ return rewriteValueARM_OpEq32_0(v)
case OpEq32F:
- return rewriteValueARM_OpEq32F(v)
+ return rewriteValueARM_OpEq32F_0(v)
case OpEq64F:
- return rewriteValueARM_OpEq64F(v)
+ return rewriteValueARM_OpEq64F_0(v)
case OpEq8:
- return rewriteValueARM_OpEq8(v)
+ return rewriteValueARM_OpEq8_0(v)
case OpEqB:
- return rewriteValueARM_OpEqB(v)
+ return rewriteValueARM_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueARM_OpEqPtr(v)
+ return rewriteValueARM_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueARM_OpGeq16(v)
+ return rewriteValueARM_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueARM_OpGeq16U(v)
+ return rewriteValueARM_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueARM_OpGeq32(v)
+ return rewriteValueARM_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueARM_OpGeq32F(v)
+ return rewriteValueARM_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueARM_OpGeq32U(v)
+ return rewriteValueARM_OpGeq32U_0(v)
case OpGeq64F:
- return rewriteValueARM_OpGeq64F(v)
+ return rewriteValueARM_OpGeq64F_0(v)
case OpGeq8:
- return rewriteValueARM_OpGeq8(v)
+ return rewriteValueARM_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueARM_OpGeq8U(v)
+ return rewriteValueARM_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueARM_OpGetClosurePtr(v)
+ return rewriteValueARM_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueARM_OpGreater16(v)
+ return rewriteValueARM_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueARM_OpGreater16U(v)
+ return rewriteValueARM_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueARM_OpGreater32(v)
+ return rewriteValueARM_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueARM_OpGreater32F(v)
+ return rewriteValueARM_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueARM_OpGreater32U(v)
+ return rewriteValueARM_OpGreater32U_0(v)
case OpGreater64F:
- return rewriteValueARM_OpGreater64F(v)
+ return rewriteValueARM_OpGreater64F_0(v)
case OpGreater8:
- return rewriteValueARM_OpGreater8(v)
+ return rewriteValueARM_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueARM_OpGreater8U(v)
+ return rewriteValueARM_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueARM_OpHmul32(v)
+ return rewriteValueARM_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueARM_OpHmul32u(v)
+ return rewriteValueARM_OpHmul32u_0(v)
case OpInterCall:
- return rewriteValueARM_OpInterCall(v)
+ return rewriteValueARM_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueARM_OpIsInBounds(v)
+ return rewriteValueARM_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueARM_OpIsNonNil(v)
+ return rewriteValueARM_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueARM_OpIsSliceInBounds(v)
+ return rewriteValueARM_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueARM_OpLeq16(v)
+ return rewriteValueARM_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueARM_OpLeq16U(v)
+ return rewriteValueARM_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueARM_OpLeq32(v)
+ return rewriteValueARM_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueARM_OpLeq32F(v)
+ return rewriteValueARM_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueARM_OpLeq32U(v)
+ return rewriteValueARM_OpLeq32U_0(v)
case OpLeq64F:
- return rewriteValueARM_OpLeq64F(v)
+ return rewriteValueARM_OpLeq64F_0(v)
case OpLeq8:
- return rewriteValueARM_OpLeq8(v)
+ return rewriteValueARM_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueARM_OpLeq8U(v)
+ return rewriteValueARM_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueARM_OpLess16(v)
+ return rewriteValueARM_OpLess16_0(v)
case OpLess16U:
- return rewriteValueARM_OpLess16U(v)
+ return rewriteValueARM_OpLess16U_0(v)
case OpLess32:
- return rewriteValueARM_OpLess32(v)
+ return rewriteValueARM_OpLess32_0(v)
case OpLess32F:
- return rewriteValueARM_OpLess32F(v)
+ return rewriteValueARM_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueARM_OpLess32U(v)
+ return rewriteValueARM_OpLess32U_0(v)
case OpLess64F:
- return rewriteValueARM_OpLess64F(v)
+ return rewriteValueARM_OpLess64F_0(v)
case OpLess8:
- return rewriteValueARM_OpLess8(v)
+ return rewriteValueARM_OpLess8_0(v)
case OpLess8U:
- return rewriteValueARM_OpLess8U(v)
+ return rewriteValueARM_OpLess8U_0(v)
case OpLoad:
- return rewriteValueARM_OpLoad(v)
+ return rewriteValueARM_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueARM_OpLsh16x16(v)
+ return rewriteValueARM_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueARM_OpLsh16x32(v)
+ return rewriteValueARM_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueARM_OpLsh16x64(v)
+ return rewriteValueARM_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueARM_OpLsh16x8(v)
+ return rewriteValueARM_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueARM_OpLsh32x16(v)
+ return rewriteValueARM_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueARM_OpLsh32x32(v)
+ return rewriteValueARM_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueARM_OpLsh32x64(v)
+ return rewriteValueARM_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueARM_OpLsh32x8(v)
+ return rewriteValueARM_OpLsh32x8_0(v)
case OpLsh8x16:
- return rewriteValueARM_OpLsh8x16(v)
+ return rewriteValueARM_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueARM_OpLsh8x32(v)
+ return rewriteValueARM_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueARM_OpLsh8x64(v)
+ return rewriteValueARM_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueARM_OpLsh8x8(v)
+ return rewriteValueARM_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueARM_OpMod16(v)
+ return rewriteValueARM_OpMod16_0(v)
case OpMod16u:
- return rewriteValueARM_OpMod16u(v)
+ return rewriteValueARM_OpMod16u_0(v)
case OpMod32:
- return rewriteValueARM_OpMod32(v)
+ return rewriteValueARM_OpMod32_0(v)
case OpMod32u:
- return rewriteValueARM_OpMod32u(v)
+ return rewriteValueARM_OpMod32u_0(v)
case OpMod8:
- return rewriteValueARM_OpMod8(v)
+ return rewriteValueARM_OpMod8_0(v)
case OpMod8u:
- return rewriteValueARM_OpMod8u(v)
+ return rewriteValueARM_OpMod8u_0(v)
case OpMove:
- return rewriteValueARM_OpMove(v)
+ return rewriteValueARM_OpMove_0(v)
case OpMul16:
- return rewriteValueARM_OpMul16(v)
+ return rewriteValueARM_OpMul16_0(v)
case OpMul32:
- return rewriteValueARM_OpMul32(v)
+ return rewriteValueARM_OpMul32_0(v)
case OpMul32F:
- return rewriteValueARM_OpMul32F(v)
+ return rewriteValueARM_OpMul32F_0(v)
case OpMul32uhilo:
- return rewriteValueARM_OpMul32uhilo(v)
+ return rewriteValueARM_OpMul32uhilo_0(v)
case OpMul64F:
- return rewriteValueARM_OpMul64F(v)
+ return rewriteValueARM_OpMul64F_0(v)
case OpMul8:
- return rewriteValueARM_OpMul8(v)
+ return rewriteValueARM_OpMul8_0(v)
case OpNeg16:
- return rewriteValueARM_OpNeg16(v)
+ return rewriteValueARM_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueARM_OpNeg32(v)
+ return rewriteValueARM_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueARM_OpNeg32F(v)
+ return rewriteValueARM_OpNeg32F_0(v)
case OpNeg64F:
- return rewriteValueARM_OpNeg64F(v)
+ return rewriteValueARM_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueARM_OpNeg8(v)
+ return rewriteValueARM_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueARM_OpNeq16(v)
+ return rewriteValueARM_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueARM_OpNeq32(v)
+ return rewriteValueARM_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueARM_OpNeq32F(v)
+ return rewriteValueARM_OpNeq32F_0(v)
case OpNeq64F:
- return rewriteValueARM_OpNeq64F(v)
+ return rewriteValueARM_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueARM_OpNeq8(v)
+ return rewriteValueARM_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueARM_OpNeqB(v)
+ return rewriteValueARM_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueARM_OpNeqPtr(v)
+ return rewriteValueARM_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueARM_OpNilCheck(v)
+ return rewriteValueARM_OpNilCheck_0(v)
case OpNot:
- return rewriteValueARM_OpNot(v)
+ return rewriteValueARM_OpNot_0(v)
case OpOffPtr:
- return rewriteValueARM_OpOffPtr(v)
+ return rewriteValueARM_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueARM_OpOr16(v)
+ return rewriteValueARM_OpOr16_0(v)
case OpOr32:
- return rewriteValueARM_OpOr32(v)
+ return rewriteValueARM_OpOr32_0(v)
case OpOr8:
- return rewriteValueARM_OpOr8(v)
+ return rewriteValueARM_OpOr8_0(v)
case OpOrB:
- return rewriteValueARM_OpOrB(v)
+ return rewriteValueARM_OpOrB_0(v)
case OpRound32F:
- return rewriteValueARM_OpRound32F(v)
+ return rewriteValueARM_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueARM_OpRound64F(v)
+ return rewriteValueARM_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueARM_OpRsh16Ux16(v)
+ return rewriteValueARM_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueARM_OpRsh16Ux32(v)
+ return rewriteValueARM_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueARM_OpRsh16Ux64(v)
+ return rewriteValueARM_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueARM_OpRsh16Ux8(v)
+ return rewriteValueARM_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueARM_OpRsh16x16(v)
+ return rewriteValueARM_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueARM_OpRsh16x32(v)
+ return rewriteValueARM_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueARM_OpRsh16x64(v)
+ return rewriteValueARM_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueARM_OpRsh16x8(v)
+ return rewriteValueARM_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueARM_OpRsh32Ux16(v)
+ return rewriteValueARM_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueARM_OpRsh32Ux32(v)
+ return rewriteValueARM_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueARM_OpRsh32Ux64(v)
+ return rewriteValueARM_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueARM_OpRsh32Ux8(v)
+ return rewriteValueARM_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueARM_OpRsh32x16(v)
+ return rewriteValueARM_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueARM_OpRsh32x32(v)
+ return rewriteValueARM_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueARM_OpRsh32x64(v)
+ return rewriteValueARM_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueARM_OpRsh32x8(v)
+ return rewriteValueARM_OpRsh32x8_0(v)
case OpRsh8Ux16:
- return rewriteValueARM_OpRsh8Ux16(v)
+ return rewriteValueARM_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueARM_OpRsh8Ux32(v)
+ return rewriteValueARM_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueARM_OpRsh8Ux64(v)
+ return rewriteValueARM_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueARM_OpRsh8Ux8(v)
+ return rewriteValueARM_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueARM_OpRsh8x16(v)
+ return rewriteValueARM_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueARM_OpRsh8x32(v)
+ return rewriteValueARM_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueARM_OpRsh8x64(v)
+ return rewriteValueARM_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueARM_OpRsh8x8(v)
+ return rewriteValueARM_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueARM_OpSelect0(v)
+ return rewriteValueARM_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueARM_OpSelect1(v)
+ return rewriteValueARM_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueARM_OpSignExt16to32(v)
+ return rewriteValueARM_OpSignExt16to32_0(v)
case OpSignExt8to16:
- return rewriteValueARM_OpSignExt8to16(v)
+ return rewriteValueARM_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueARM_OpSignExt8to32(v)
+ return rewriteValueARM_OpSignExt8to32_0(v)
case OpSignmask:
- return rewriteValueARM_OpSignmask(v)
+ return rewriteValueARM_OpSignmask_0(v)
case OpSlicemask:
- return rewriteValueARM_OpSlicemask(v)
+ return rewriteValueARM_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueARM_OpSqrt(v)
+ return rewriteValueARM_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueARM_OpStaticCall(v)
+ return rewriteValueARM_OpStaticCall_0(v)
case OpStore:
- return rewriteValueARM_OpStore(v)
+ return rewriteValueARM_OpStore_0(v)
case OpSub16:
- return rewriteValueARM_OpSub16(v)
+ return rewriteValueARM_OpSub16_0(v)
case OpSub32:
- return rewriteValueARM_OpSub32(v)
+ return rewriteValueARM_OpSub32_0(v)
case OpSub32F:
- return rewriteValueARM_OpSub32F(v)
+ return rewriteValueARM_OpSub32F_0(v)
case OpSub32carry:
- return rewriteValueARM_OpSub32carry(v)
+ return rewriteValueARM_OpSub32carry_0(v)
case OpSub32withcarry:
- return rewriteValueARM_OpSub32withcarry(v)
+ return rewriteValueARM_OpSub32withcarry_0(v)
case OpSub64F:
- return rewriteValueARM_OpSub64F(v)
+ return rewriteValueARM_OpSub64F_0(v)
case OpSub8:
- return rewriteValueARM_OpSub8(v)
+ return rewriteValueARM_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueARM_OpSubPtr(v)
+ return rewriteValueARM_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueARM_OpTrunc16to8(v)
+ return rewriteValueARM_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueARM_OpTrunc32to16(v)
+ return rewriteValueARM_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueARM_OpTrunc32to8(v)
+ return rewriteValueARM_OpTrunc32to8_0(v)
case OpXor16:
- return rewriteValueARM_OpXor16(v)
+ return rewriteValueARM_OpXor16_0(v)
case OpXor32:
- return rewriteValueARM_OpXor32(v)
+ return rewriteValueARM_OpXor32_0(v)
case OpXor8:
- return rewriteValueARM_OpXor8(v)
+ return rewriteValueARM_OpXor8_0(v)
case OpZero:
- return rewriteValueARM_OpZero(v)
+ return rewriteValueARM_OpZero_0(v)
case OpZeroExt16to32:
- return rewriteValueARM_OpZeroExt16to32(v)
+ return rewriteValueARM_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
- return rewriteValueARM_OpZeroExt8to16(v)
+ return rewriteValueARM_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueARM_OpZeroExt8to32(v)
+ return rewriteValueARM_OpZeroExt8to32_0(v)
case OpZeromask:
- return rewriteValueARM_OpZeromask(v)
+ return rewriteValueARM_OpZeromask_0(v)
}
return false
}
-func rewriteValueARM_OpARMADC(v *Value) bool {
+func rewriteValueARM_OpARMADC_0(v *Value) bool {
// match: (ADC (MOVWconst [c]) x flags)
// cond:
// result: (ADCconst [c] x flags)
@@ -911,6 +911,9 @@
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADC_10(v *Value) bool {
// match: (ADC (SRLconst [c] y) x flags)
// cond:
// result: (ADCshiftRL x y [c] flags)
@@ -1101,6 +1104,9 @@
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADC_20(v *Value) bool {
// match: (ADC x (SRL y z) flags)
// cond:
// result: (ADCshiftRLreg x y z flags)
@@ -1255,7 +1261,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCconst(v *Value) bool {
+func rewriteValueARM_OpARMADCconst_0(v *Value) bool {
// match: (ADCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (ADCconst [int64(int32(c+d))] x flags)
@@ -1294,7 +1300,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftLL (MOVWconst [c]) x [d] flags)
@@ -1338,7 +1344,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftLLreg (MOVWconst [c]) x y flags)
@@ -1383,7 +1389,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRA (MOVWconst [c]) x [d] flags)
@@ -1427,7 +1433,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRAreg (MOVWconst [c]) x y flags)
@@ -1472,7 +1478,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRL (MOVWconst [c]) x [d] flags)
@@ -1516,7 +1522,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRLreg (MOVWconst [c]) x y flags)
@@ -1561,9 +1567,7 @@
}
return false
}
-func rewriteValueARM_OpARMADD(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM_OpARMADD_0(v *Value) bool {
// match: (ADD x (MOVWconst [c]))
// cond:
// result: (ADDconst [c] x)
@@ -1730,6 +1734,11 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADD_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ADD x (SRL y z))
// cond:
// result: (ADDshiftRLreg x y z)
@@ -1920,7 +1929,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDS(v *Value) bool {
+func rewriteValueARM_OpARMADDS_0(v *Value) bool {
// match: (ADDS x (MOVWconst [c]))
// cond:
// result: (ADDSconst [c] x)
@@ -2087,6 +2096,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADDS_10(v *Value) bool {
// match: (ADDS x (SRL y z))
// cond:
// result: (ADDSshiftRLreg x y z)
@@ -2157,7 +2169,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftLL (MOVWconst [c]) x [d])
@@ -2197,7 +2209,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftLLreg (MOVWconst [c]) x y)
@@ -2238,7 +2250,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRA (MOVWconst [c]) x [d])
@@ -2278,7 +2290,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRAreg (MOVWconst [c]) x y)
@@ -2319,7 +2331,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRL (MOVWconst [c]) x [d])
@@ -2359,7 +2371,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRLreg (MOVWconst [c]) x y)
@@ -2400,7 +2412,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDconst(v *Value) bool {
+func rewriteValueARM_OpARMADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// cond:
// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2496,7 +2508,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLL (MOVWconst [c]) x [d])
@@ -2557,7 +2569,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLLreg (MOVWconst [c]) x y)
@@ -2598,7 +2610,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRA (MOVWconst [c]) x [d])
@@ -2638,7 +2650,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRAreg (MOVWconst [c]) x y)
@@ -2679,7 +2691,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRL (MOVWconst [c]) x [d])
@@ -2740,7 +2752,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRLreg (MOVWconst [c]) x y)
@@ -2781,7 +2793,7 @@
}
return false
}
-func rewriteValueARM_OpARMAND(v *Value) bool {
+func rewriteValueARM_OpARMAND_0(v *Value) bool {
// match: (AND x (MOVWconst [c]))
// cond:
// result: (ANDconst [c] x)
@@ -2948,6 +2960,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMAND_10(v *Value) bool {
// match: (AND x (SRL y z))
// cond:
// result: (ANDshiftRLreg x y z)
@@ -3110,6 +3125,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMAND_20(v *Value) bool {
// match: (AND (MVNshiftRL y [c]) x)
// cond:
// result: (BICshiftRL x y [c])
@@ -3163,7 +3181,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDconst(v *Value) bool {
+func rewriteValueARM_OpARMANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVWconst [0])
@@ -3221,7 +3239,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLL (MOVWconst [c]) x [d])
@@ -3283,7 +3301,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLLreg (MOVWconst [c]) x y)
@@ -3324,7 +3342,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRA (MOVWconst [c]) x [d])
@@ -3386,7 +3404,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRAreg (MOVWconst [c]) x y)
@@ -3427,7 +3445,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRL (MOVWconst [c]) x [d])
@@ -3489,7 +3507,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRLreg (MOVWconst [c]) x y)
@@ -3530,7 +3548,7 @@
}
return false
}
-func rewriteValueARM_OpARMBIC(v *Value) bool {
+func rewriteValueARM_OpARMBIC_0(v *Value) bool {
// match: (BIC x (MOVWconst [c]))
// cond:
// result: (BICconst [c] x)
@@ -3662,7 +3680,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICconst(v *Value) bool {
+func rewriteValueARM_OpARMBICconst_0(v *Value) bool {
// match: (BICconst [0] x)
// cond:
// result: x
@@ -3704,7 +3722,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool {
// match: (BICshiftLL x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint32(c)<<uint64(d))])
@@ -3744,7 +3762,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool {
// match: (BICshiftLLreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftLL x y [c])
@@ -3764,7 +3782,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool {
// match: (BICshiftRA x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(int32(c)>>uint64(d))])
@@ -3804,7 +3822,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool {
// match: (BICshiftRAreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftRA x y [c])
@@ -3824,7 +3842,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool {
// match: (BICshiftRL x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint32(c)>>uint64(d))])
@@ -3864,7 +3882,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool {
// match: (BICshiftRLreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftRL x y [c])
@@ -3884,7 +3902,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool {
// match: (CMOVWHSconst _ (FlagEQ) [c])
// cond:
// result: (MOVWconst [c])
@@ -3971,7 +3989,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool {
// match: (CMOVWLSconst _ (FlagEQ) [c])
// cond:
// result: (MOVWconst [c])
@@ -4058,7 +4076,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMP(v *Value) bool {
+func rewriteValueARM_OpARMCMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVWconst [c]))
@@ -4237,6 +4255,11 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMCMP_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (CMP x (SRL y z))
// cond:
// result: (CMPshiftRLreg x y z)
@@ -4311,7 +4334,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPD(v *Value) bool {
+func rewriteValueARM_OpARMCMPD_0(v *Value) bool {
// match: (CMPD x (MOVDconst [0]))
// cond:
// result: (CMPD0 x)
@@ -4330,7 +4353,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPF(v *Value) bool {
+func rewriteValueARM_OpARMCMPF_0(v *Value) bool {
// match: (CMPF x (MOVFconst [0]))
// cond:
// result: (CMPF0 x)
@@ -4349,7 +4372,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPconst(v *Value) bool {
+func rewriteValueARM_OpARMCMPconst_0(v *Value) bool {
// match: (CMPconst (MOVWconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -4494,7 +4517,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLL (MOVWconst [c]) x [d])
@@ -4536,7 +4559,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLLreg (MOVWconst [c]) x y)
@@ -4579,7 +4602,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRA (MOVWconst [c]) x [d])
@@ -4621,7 +4644,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRAreg (MOVWconst [c]) x y)
@@ -4664,7 +4687,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRL (MOVWconst [c]) x [d])
@@ -4706,7 +4729,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRLreg (MOVWconst [c]) x y)
@@ -4749,7 +4772,7 @@
}
return false
}
-func rewriteValueARM_OpARMEqual(v *Value) bool {
+func rewriteValueARM_OpARMEqual_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVWconst [1])
@@ -4825,7 +4848,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqual(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVWconst [1])
@@ -4901,7 +4924,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool {
// match: (GreaterEqualU (FlagEQ))
// cond:
// result: (MOVWconst [1])
@@ -4977,7 +5000,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThan(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVWconst [0])
@@ -5053,7 +5076,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThanU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool {
// match: (GreaterThanU (FlagEQ))
// cond:
// result: (MOVWconst [0])
@@ -5129,7 +5152,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqual(v *Value) bool {
+func rewriteValueARM_OpARMLessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVWconst [1])
@@ -5205,7 +5228,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqualU(v *Value) bool {
+func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool {
// match: (LessEqualU (FlagEQ))
// cond:
// result: (MOVWconst [1])
@@ -5281,7 +5304,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThan(v *Value) bool {
+func rewriteValueARM_OpARMLessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVWconst [0])
@@ -5357,7 +5380,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThanU(v *Value) bool {
+func rewriteValueARM_OpARMLessThanU_0(v *Value) bool {
// match: (LessThanU (FlagEQ))
// cond:
// result: (MOVWconst [0])
@@ -5433,7 +5456,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -5503,7 +5526,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVWreg x)
@@ -5558,7 +5581,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -5628,7 +5651,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVWreg x)
@@ -5686,7 +5709,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -5821,7 +5844,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDload(v *Value) bool {
+func rewriteValueARM_OpARMMOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVDload [off1+off2] {sym} ptr mem)
@@ -5891,7 +5914,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -5942,7 +5965,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFload(v *Value) bool {
+func rewriteValueARM_OpARMMOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVFload [off1+off2] {sym} ptr mem)
@@ -6012,7 +6035,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
@@ -6063,7 +6086,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -6133,7 +6156,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVWreg x)
@@ -6212,7 +6235,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -6282,7 +6305,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVWreg x)
@@ -6388,7 +6411,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -6481,7 +6504,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWload(v *Value) bool {
+func rewriteValueARM_OpARMMOVWload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -6657,7 +6680,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool {
// match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _))
// cond: isSamePtr(ptr, ptr2)
// result: x
@@ -6831,7 +6854,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool {
// match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
@@ -6877,7 +6900,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool {
// match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
@@ -6923,7 +6946,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool {
// match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
@@ -6969,7 +6992,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool {
// match: (MOVWreg x)
// cond: x.Uses == 1
// result: (MOVWnop x)
@@ -6997,7 +7020,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -7162,7 +7185,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool {
// match: (MOVWstoreidx ptr (MOVWconst [c]) val mem)
// cond:
// result: (MOVWstore [c] ptr val mem)
@@ -7329,7 +7352,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool {
// match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem)
@@ -7352,7 +7375,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool {
// match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem)
@@ -7375,7 +7398,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool {
// match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem)
@@ -7398,9 +7421,7 @@
}
return false
}
-func rewriteValueARM_OpARMMUL(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM_OpARMMUL_0(v *Value) bool {
// match: (MUL x (MOVWconst [c]))
// cond: int32(c) == -1
// result: (RSBconst [0] x)
@@ -7575,6 +7596,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMUL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MUL x (MOVWconst [c]))
// cond: isPowerOfTwo(c+1) && int32(c) >= 7
// result: (RSBshiftLL x x [log2(c+1)])
@@ -7789,6 +7815,9 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMUL_20(v *Value) bool {
// match: (MUL (MOVWconst [c]) (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(c*d))])
@@ -7827,7 +7856,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULA(v *Value) bool {
+func rewriteValueARM_OpARMMULA_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULA x (MOVWconst [c]) a)
@@ -8056,6 +8085,11 @@
v.AddArg(a)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMULA_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULA (MOVWconst [c]) x a)
// cond: int32(c) == -1
// result: (SUB a x)
@@ -8282,6 +8316,9 @@
v.AddArg(a)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMULA_20(v *Value) bool {
// match: (MULA (MOVWconst [c]) (MOVWconst [d]) a)
// cond:
// result: (ADDconst [int64(int32(c*d))] a)
@@ -8304,7 +8341,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVN(v *Value) bool {
+func rewriteValueARM_OpARMMVN_0(v *Value) bool {
// match: (MVN (MOVWconst [c]))
// cond:
// result: (MOVWconst [^c])
@@ -8410,7 +8447,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool {
// match: (MVNshiftLL (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(uint32(c)<<uint64(d))])
@@ -8427,7 +8464,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool {
// match: (MVNshiftLLreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftLL x [c])
@@ -8445,7 +8482,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool {
// match: (MVNshiftRA (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(int32(c)>>uint64(d))])
@@ -8462,7 +8499,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool {
// match: (MVNshiftRAreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftRA x [c])
@@ -8480,7 +8517,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool {
// match: (MVNshiftRL (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(uint32(c)>>uint64(d))])
@@ -8497,7 +8534,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool {
// match: (MVNshiftRLreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftRL x [c])
@@ -8515,7 +8552,7 @@
}
return false
}
-func rewriteValueARM_OpARMNotEqual(v *Value) bool {
+func rewriteValueARM_OpARMNotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVWconst [0])
@@ -8591,7 +8628,7 @@
}
return false
}
-func rewriteValueARM_OpARMOR(v *Value) bool {
+func rewriteValueARM_OpARMOR_0(v *Value) bool {
// match: (OR x (MOVWconst [c]))
// cond:
// result: (ORconst [c] x)
@@ -8758,6 +8795,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMOR_10(v *Value) bool {
// match: (OR x (SRL y z))
// cond:
// result: (ORshiftRLreg x y z)
@@ -8841,7 +8881,7 @@
}
return false
}
-func rewriteValueARM_OpARMORconst(v *Value) bool {
+func rewriteValueARM_OpARMORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
@@ -8899,7 +8939,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLL (MOVWconst [c]) x [d])
@@ -8982,7 +9022,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLLreg (MOVWconst [c]) x y)
@@ -9023,7 +9063,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRA (MOVWconst [c]) x [d])
@@ -9085,7 +9125,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRAreg (MOVWconst [c]) x y)
@@ -9126,7 +9166,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRL (MOVWconst [c]) x [d])
@@ -9209,7 +9249,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRLreg (MOVWconst [c]) x y)
@@ -9250,7 +9290,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSB(v *Value) bool {
+func rewriteValueARM_OpARMRSB_0(v *Value) bool {
// match: (RSB (MOVWconst [c]) x)
// cond:
// result: (SUBconst [c] x)
@@ -9417,6 +9457,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMRSB_10(v *Value) bool {
// match: (RSB x (SRL y z))
// cond:
// result: (RSBshiftRLreg x y z)
@@ -9499,7 +9542,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftLL (MOVWconst [c]) x [d])
@@ -9539,7 +9582,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftLLreg (MOVWconst [c]) x y)
@@ -9580,7 +9623,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRA (MOVWconst [c]) x [d])
@@ -9620,7 +9663,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRAreg (MOVWconst [c]) x y)
@@ -9661,7 +9704,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRL (MOVWconst [c]) x [d])
@@ -9701,7 +9744,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRLreg (MOVWconst [c]) x y)
@@ -9742,7 +9785,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBconst(v *Value) bool {
+func rewriteValueARM_OpARMRSBconst_0(v *Value) bool {
// match: (RSBconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(c-d))])
@@ -9807,7 +9850,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftLL (MOVWconst [c]) x [d])
@@ -9868,7 +9911,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftLLreg (MOVWconst [c]) x y)
@@ -9909,7 +9952,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRA (MOVWconst [c]) x [d])
@@ -9970,7 +10013,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRAreg (MOVWconst [c]) x y)
@@ -10011,7 +10054,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRL (MOVWconst [c]) x [d])
@@ -10072,7 +10115,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRLreg (MOVWconst [c]) x y)
@@ -10113,7 +10156,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCconst(v *Value) bool {
+func rewriteValueARM_OpARMRSCconst_0(v *Value) bool {
// match: (RSCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (RSCconst [int64(int32(c-d))] x flags)
@@ -10152,7 +10195,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftLL (MOVWconst [c]) x [d] flags)
@@ -10196,7 +10239,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftLLreg (MOVWconst [c]) x y flags)
@@ -10241,7 +10284,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRA (MOVWconst [c]) x [d] flags)
@@ -10285,7 +10328,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRAreg (MOVWconst [c]) x y flags)
@@ -10330,7 +10373,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRL (MOVWconst [c]) x [d] flags)
@@ -10374,7 +10417,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRLreg (MOVWconst [c]) x y flags)
@@ -10419,7 +10462,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBC(v *Value) bool {
+func rewriteValueARM_OpARMSBC_0(v *Value) bool {
// match: (SBC (MOVWconst [c]) x flags)
// cond:
// result: (RSCconst [c] x flags)
@@ -10606,6 +10649,9 @@
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSBC_10(v *Value) bool {
// match: (SBC x (SRL y z) flags)
// cond:
// result: (SBCshiftRLreg x y z flags)
@@ -10684,7 +10730,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCconst(v *Value) bool {
+func rewriteValueARM_OpARMSBCconst_0(v *Value) bool {
// match: (SBCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (SBCconst [int64(int32(c-d))] x flags)
@@ -10723,7 +10769,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftLL (MOVWconst [c]) x [d] flags)
@@ -10767,7 +10813,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftLLreg (MOVWconst [c]) x y flags)
@@ -10812,7 +10858,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRA (MOVWconst [c]) x [d] flags)
@@ -10856,7 +10902,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRAreg (MOVWconst [c]) x y flags)
@@ -10901,7 +10947,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRL (MOVWconst [c]) x [d] flags)
@@ -10945,7 +10991,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRLreg (MOVWconst [c]) x y flags)
@@ -10990,7 +11036,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLL(v *Value) bool {
+func rewriteValueARM_OpARMSLL_0(v *Value) bool {
// match: (SLL x (MOVWconst [c]))
// cond:
// result: (SLLconst x [c&31])
@@ -11008,7 +11054,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLLconst(v *Value) bool {
+func rewriteValueARM_OpARMSLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)<<uint64(c))])
@@ -11025,7 +11071,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRA(v *Value) bool {
+func rewriteValueARM_OpARMSRA_0(v *Value) bool {
// match: (SRA x (MOVWconst [c]))
// cond:
// result: (SRAconst x [c&31])
@@ -11043,7 +11089,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAcond(v *Value) bool {
+func rewriteValueARM_OpARMSRAcond_0(v *Value) bool {
// match: (SRAcond x _ (FlagEQ))
// cond:
// result: (SRAconst x [31])
@@ -11118,7 +11164,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAconst(v *Value) bool {
+func rewriteValueARM_OpARMSRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(d)>>uint64(c))])
@@ -11135,7 +11181,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRL(v *Value) bool {
+func rewriteValueARM_OpARMSRL_0(v *Value) bool {
// match: (SRL x (MOVWconst [c]))
// cond:
// result: (SRLconst x [c&31])
@@ -11153,7 +11199,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRLconst(v *Value) bool {
+func rewriteValueARM_OpARMSRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)>>uint64(c))])
@@ -11170,7 +11216,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUB(v *Value) bool {
+func rewriteValueARM_OpARMSUB_0(v *Value) bool {
// match: (SUB (MOVWconst [c]) x)
// cond:
// result: (RSBconst [c] x)
@@ -11337,6 +11383,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSUB_10(v *Value) bool {
// match: (SUB x (SRL y z))
// cond:
// result: (SUBshiftRLreg x y z)
@@ -11419,7 +11468,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBS(v *Value) bool {
+func rewriteValueARM_OpARMSUBS_0(v *Value) bool {
// match: (SUBS x (MOVWconst [c]))
// cond:
// result: (SUBSconst [c] x)
@@ -11588,6 +11637,9 @@
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSUBS_10(v *Value) bool {
// match: (SUBS (SRL y z) x)
// cond:
// result: (RSBSshiftRLreg x y z)
@@ -11641,7 +11693,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftLL (MOVWconst [c]) x [d])
@@ -11681,7 +11733,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftLLreg (MOVWconst [c]) x y)
@@ -11722,7 +11774,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRA (MOVWconst [c]) x [d])
@@ -11762,7 +11814,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRAreg (MOVWconst [c]) x y)
@@ -11803,7 +11855,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRL (MOVWconst [c]) x [d])
@@ -11843,7 +11895,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRLreg (MOVWconst [c]) x y)
@@ -11884,7 +11936,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBconst(v *Value) bool {
+func rewriteValueARM_OpARMSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
@@ -11962,7 +12014,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftLL (MOVWconst [c]) x [d])
@@ -12023,7 +12075,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftLLreg (MOVWconst [c]) x y)
@@ -12064,7 +12116,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRA (MOVWconst [c]) x [d])
@@ -12125,7 +12177,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRAreg (MOVWconst [c]) x y)
@@ -12166,7 +12218,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRL (MOVWconst [c]) x [d])
@@ -12227,7 +12279,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRLreg (MOVWconst [c]) x y)
@@ -12268,7 +12320,7 @@
}
return false
}
-func rewriteValueARM_OpARMXOR(v *Value) bool {
+func rewriteValueARM_OpARMXOR_0(v *Value) bool {
// match: (XOR x (MOVWconst [c]))
// cond:
// result: (XORconst [c] x)
@@ -12435,6 +12487,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMXOR_10(v *Value) bool {
// match: (XOR x (SLL y z))
// cond:
// result: (XORshiftLLreg x y z)
@@ -12551,7 +12606,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORconst(v *Value) bool {
+func rewriteValueARM_OpARMXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
@@ -12597,7 +12652,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLL (MOVWconst [c]) x [d])
@@ -12679,7 +12734,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLLreg (MOVWconst [c]) x y)
@@ -12720,7 +12775,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRA (MOVWconst [c]) x [d])
@@ -12781,7 +12836,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRAreg (MOVWconst [c]) x y)
@@ -12822,7 +12877,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRL (MOVWconst [c]) x [d])
@@ -12904,7 +12959,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRLreg (MOVWconst [c]) x y)
@@ -12945,7 +13000,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRR(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRR (MOVWconst [c]) x [d])
@@ -12985,7 +13040,7 @@
}
return false
}
-func rewriteValueARM_OpAdd16(v *Value) bool {
+func rewriteValueARM_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
@@ -12998,7 +13053,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32(v *Value) bool {
+func rewriteValueARM_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
@@ -13011,7 +13066,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32F(v *Value) bool {
+func rewriteValueARM_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
@@ -13024,7 +13079,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32carry(v *Value) bool {
+func rewriteValueARM_OpAdd32carry_0(v *Value) bool {
// match: (Add32carry x y)
// cond:
// result: (ADDS x y)
@@ -13037,7 +13092,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32withcarry(v *Value) bool {
+func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool {
// match: (Add32withcarry x y c)
// cond:
// result: (ADC x y c)
@@ -13052,7 +13107,7 @@
return true
}
}
-func rewriteValueARM_OpAdd64F(v *Value) bool {
+func rewriteValueARM_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
@@ -13065,7 +13120,7 @@
return true
}
}
-func rewriteValueARM_OpAdd8(v *Value) bool {
+func rewriteValueARM_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
@@ -13078,7 +13133,7 @@
return true
}
}
-func rewriteValueARM_OpAddPtr(v *Value) bool {
+func rewriteValueARM_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
@@ -13091,7 +13146,7 @@
return true
}
}
-func rewriteValueARM_OpAddr(v *Value) bool {
+func rewriteValueARM_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVWaddr {sym} base)
@@ -13104,7 +13159,7 @@
return true
}
}
-func rewriteValueARM_OpAnd16(v *Value) bool {
+func rewriteValueARM_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
@@ -13117,7 +13172,7 @@
return true
}
}
-func rewriteValueARM_OpAnd32(v *Value) bool {
+func rewriteValueARM_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
@@ -13130,7 +13185,7 @@
return true
}
}
-func rewriteValueARM_OpAnd8(v *Value) bool {
+func rewriteValueARM_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
@@ -13143,7 +13198,7 @@
return true
}
}
-func rewriteValueARM_OpAndB(v *Value) bool {
+func rewriteValueARM_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
@@ -13156,7 +13211,7 @@
return true
}
}
-func rewriteValueARM_OpAvg32u(v *Value) bool {
+func rewriteValueARM_OpAvg32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg32u <t> x y)
@@ -13178,7 +13233,7 @@
return true
}
}
-func rewriteValueARM_OpBitLen32(v *Value) bool {
+func rewriteValueARM_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
// match: (BitLen32 <t> x)
@@ -13195,7 +13250,7 @@
return true
}
}
-func rewriteValueARM_OpBswap32(v *Value) bool {
+func rewriteValueARM_OpBswap32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Bswap32 <t> x)
@@ -13242,7 +13297,7 @@
}
return false
}
-func rewriteValueARM_OpClosureCall(v *Value) bool {
+func rewriteValueARM_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -13259,7 +13314,7 @@
return true
}
}
-func rewriteValueARM_OpCom16(v *Value) bool {
+func rewriteValueARM_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (MVN x)
@@ -13270,7 +13325,7 @@
return true
}
}
-func rewriteValueARM_OpCom32(v *Value) bool {
+func rewriteValueARM_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (MVN x)
@@ -13281,7 +13336,7 @@
return true
}
}
-func rewriteValueARM_OpCom8(v *Value) bool {
+func rewriteValueARM_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (MVN x)
@@ -13292,7 +13347,7 @@
return true
}
}
-func rewriteValueARM_OpConst16(v *Value) bool {
+func rewriteValueARM_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVWconst [val])
@@ -13303,7 +13358,7 @@
return true
}
}
-func rewriteValueARM_OpConst32(v *Value) bool {
+func rewriteValueARM_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVWconst [val])
@@ -13314,7 +13369,7 @@
return true
}
}
-func rewriteValueARM_OpConst32F(v *Value) bool {
+func rewriteValueARM_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
@@ -13325,7 +13380,7 @@
return true
}
}
-func rewriteValueARM_OpConst64F(v *Value) bool {
+func rewriteValueARM_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
@@ -13336,7 +13391,7 @@
return true
}
}
-func rewriteValueARM_OpConst8(v *Value) bool {
+func rewriteValueARM_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVWconst [val])
@@ -13347,7 +13402,7 @@
return true
}
}
-func rewriteValueARM_OpConstBool(v *Value) bool {
+func rewriteValueARM_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVWconst [b])
@@ -13358,7 +13413,7 @@
return true
}
}
-func rewriteValueARM_OpConstNil(v *Value) bool {
+func rewriteValueARM_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVWconst [0])
@@ -13368,7 +13423,7 @@
return true
}
}
-func rewriteValueARM_OpConvert(v *Value) bool {
+func rewriteValueARM_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVWconvert x mem)
@@ -13381,7 +13436,7 @@
return true
}
}
-func rewriteValueARM_OpCtz32(v *Value) bool {
+func rewriteValueARM_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz32 <t> x)
@@ -13427,7 +13482,7 @@
}
return false
}
-func rewriteValueARM_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (MOVFW x)
@@ -13438,7 +13493,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool {
// match: (Cvt32Fto32U x)
// cond:
// result: (MOVFWU x)
@@ -13449,7 +13504,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
@@ -13460,7 +13515,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool {
// match: (Cvt32Uto32F x)
// cond:
// result: (MOVWUF x)
@@ -13471,7 +13526,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool {
// match: (Cvt32Uto64F x)
// cond:
// result: (MOVWUD x)
@@ -13482,7 +13537,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
@@ -13493,7 +13548,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
@@ -13504,7 +13559,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (MOVDW x)
@@ -13515,7 +13570,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
@@ -13526,7 +13581,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool {
// match: (Cvt64Fto32U x)
// cond:
// result: (MOVDWU x)
@@ -13537,7 +13592,7 @@
return true
}
}
-func rewriteValueARM_OpDiv16(v *Value) bool {
+func rewriteValueARM_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13558,7 +13613,7 @@
return true
}
}
-func rewriteValueARM_OpDiv16u(v *Value) bool {
+func rewriteValueARM_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13579,7 +13634,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32(v *Value) bool {
+func rewriteValueARM_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13634,7 +13689,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32F(v *Value) bool {
+func rewriteValueARM_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
@@ -13647,7 +13702,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32u(v *Value) bool {
+func rewriteValueARM_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13667,7 +13722,7 @@
return true
}
}
-func rewriteValueARM_OpDiv64F(v *Value) bool {
+func rewriteValueARM_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
@@ -13680,7 +13735,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8(v *Value) bool {
+func rewriteValueARM_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13701,7 +13756,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8u(v *Value) bool {
+func rewriteValueARM_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13722,7 +13777,7 @@
return true
}
}
-func rewriteValueARM_OpEq16(v *Value) bool {
+func rewriteValueARM_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13745,7 +13800,7 @@
return true
}
}
-func rewriteValueARM_OpEq32(v *Value) bool {
+func rewriteValueARM_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
@@ -13762,7 +13817,7 @@
return true
}
}
-func rewriteValueARM_OpEq32F(v *Value) bool {
+func rewriteValueARM_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -13779,7 +13834,7 @@
return true
}
}
-func rewriteValueARM_OpEq64F(v *Value) bool {
+func rewriteValueARM_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -13796,7 +13851,7 @@
return true
}
}
-func rewriteValueARM_OpEq8(v *Value) bool {
+func rewriteValueARM_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13819,7 +13874,7 @@
return true
}
}
-func rewriteValueARM_OpEqB(v *Value) bool {
+func rewriteValueARM_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13839,7 +13894,7 @@
return true
}
}
-func rewriteValueARM_OpEqPtr(v *Value) bool {
+func rewriteValueARM_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
@@ -13856,7 +13911,7 @@
return true
}
}
-func rewriteValueARM_OpGeq16(v *Value) bool {
+func rewriteValueARM_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13879,7 +13934,7 @@
return true
}
}
-func rewriteValueARM_OpGeq16U(v *Value) bool {
+func rewriteValueARM_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13902,7 +13957,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32(v *Value) bool {
+func rewriteValueARM_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
@@ -13919,7 +13974,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32F(v *Value) bool {
+func rewriteValueARM_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -13936,7 +13991,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32U(v *Value) bool {
+func rewriteValueARM_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
@@ -13953,7 +14008,7 @@
return true
}
}
-func rewriteValueARM_OpGeq64F(v *Value) bool {
+func rewriteValueARM_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -13970,7 +14025,7 @@
return true
}
}
-func rewriteValueARM_OpGeq8(v *Value) bool {
+func rewriteValueARM_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13993,7 +14048,7 @@
return true
}
}
-func rewriteValueARM_OpGeq8U(v *Value) bool {
+func rewriteValueARM_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14016,7 +14071,7 @@
return true
}
}
-func rewriteValueARM_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -14025,7 +14080,7 @@
return true
}
}
-func rewriteValueARM_OpGreater16(v *Value) bool {
+func rewriteValueARM_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14048,7 +14103,7 @@
return true
}
}
-func rewriteValueARM_OpGreater16U(v *Value) bool {
+func rewriteValueARM_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14071,7 +14126,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32(v *Value) bool {
+func rewriteValueARM_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
@@ -14088,7 +14143,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32F(v *Value) bool {
+func rewriteValueARM_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -14105,7 +14160,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32U(v *Value) bool {
+func rewriteValueARM_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
@@ -14122,7 +14177,7 @@
return true
}
}
-func rewriteValueARM_OpGreater64F(v *Value) bool {
+func rewriteValueARM_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -14139,7 +14194,7 @@
return true
}
}
-func rewriteValueARM_OpGreater8(v *Value) bool {
+func rewriteValueARM_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14162,7 +14217,7 @@
return true
}
}
-func rewriteValueARM_OpGreater8U(v *Value) bool {
+func rewriteValueARM_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14185,7 +14240,7 @@
return true
}
}
-func rewriteValueARM_OpHmul32(v *Value) bool {
+func rewriteValueARM_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMUL x y)
@@ -14198,7 +14253,7 @@
return true
}
}
-func rewriteValueARM_OpHmul32u(v *Value) bool {
+func rewriteValueARM_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULU x y)
@@ -14211,7 +14266,7 @@
return true
}
}
-func rewriteValueARM_OpInterCall(v *Value) bool {
+func rewriteValueARM_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -14226,7 +14281,7 @@
return true
}
}
-func rewriteValueARM_OpIsInBounds(v *Value) bool {
+func rewriteValueARM_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
@@ -14243,7 +14298,7 @@
return true
}
}
-func rewriteValueARM_OpIsNonNil(v *Value) bool {
+func rewriteValueARM_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
@@ -14259,7 +14314,7 @@
return true
}
}
-func rewriteValueARM_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
@@ -14276,7 +14331,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16(v *Value) bool {
+func rewriteValueARM_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14299,7 +14354,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16U(v *Value) bool {
+func rewriteValueARM_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14322,7 +14377,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32(v *Value) bool {
+func rewriteValueARM_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
@@ -14339,7 +14394,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32F(v *Value) bool {
+func rewriteValueARM_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -14356,7 +14411,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32U(v *Value) bool {
+func rewriteValueARM_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
@@ -14373,7 +14428,7 @@
return true
}
}
-func rewriteValueARM_OpLeq64F(v *Value) bool {
+func rewriteValueARM_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -14390,7 +14445,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8(v *Value) bool {
+func rewriteValueARM_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14413,7 +14468,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8U(v *Value) bool {
+func rewriteValueARM_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14436,7 +14491,7 @@
return true
}
}
-func rewriteValueARM_OpLess16(v *Value) bool {
+func rewriteValueARM_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14459,7 +14514,7 @@
return true
}
}
-func rewriteValueARM_OpLess16U(v *Value) bool {
+func rewriteValueARM_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14482,7 +14537,7 @@
return true
}
}
-func rewriteValueARM_OpLess32(v *Value) bool {
+func rewriteValueARM_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
@@ -14499,7 +14554,7 @@
return true
}
}
-func rewriteValueARM_OpLess32F(v *Value) bool {
+func rewriteValueARM_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -14516,7 +14571,7 @@
return true
}
}
-func rewriteValueARM_OpLess32U(v *Value) bool {
+func rewriteValueARM_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
@@ -14533,7 +14588,7 @@
return true
}
}
-func rewriteValueARM_OpLess64F(v *Value) bool {
+func rewriteValueARM_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -14550,7 +14605,7 @@
return true
}
}
-func rewriteValueARM_OpLess8(v *Value) bool {
+func rewriteValueARM_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14573,7 +14628,7 @@
return true
}
}
-func rewriteValueARM_OpLess8U(v *Value) bool {
+func rewriteValueARM_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14596,7 +14651,7 @@
return true
}
}
-func rewriteValueARM_OpLoad(v *Value) bool {
+func rewriteValueARM_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
@@ -14719,7 +14774,7 @@
}
return false
}
-func rewriteValueARM_OpLsh16x16(v *Value) bool {
+func rewriteValueARM_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14747,7 +14802,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x32(v *Value) bool {
+func rewriteValueARM_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 x y)
@@ -14769,7 +14824,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x64(v *Value) bool {
+func rewriteValueARM_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SLLconst x [c])
@@ -14806,7 +14861,7 @@
}
return false
}
-func rewriteValueARM_OpLsh16x8(v *Value) bool {
+func rewriteValueARM_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14825,7 +14880,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x16(v *Value) bool {
+func rewriteValueARM_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14853,7 +14908,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x32(v *Value) bool {
+func rewriteValueARM_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 x y)
@@ -14875,7 +14930,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x64(v *Value) bool {
+func rewriteValueARM_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SLLconst x [c])
@@ -14912,7 +14967,7 @@
}
return false
}
-func rewriteValueARM_OpLsh32x8(v *Value) bool {
+func rewriteValueARM_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14931,7 +14986,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x16(v *Value) bool {
+func rewriteValueARM_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14959,7 +15014,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x32(v *Value) bool {
+func rewriteValueARM_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 x y)
@@ -14981,7 +15036,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x64(v *Value) bool {
+func rewriteValueARM_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SLLconst x [c])
@@ -15018,7 +15073,7 @@
}
return false
}
-func rewriteValueARM_OpLsh8x8(v *Value) bool {
+func rewriteValueARM_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15037,7 +15092,7 @@
return true
}
}
-func rewriteValueARM_OpMod16(v *Value) bool {
+func rewriteValueARM_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15058,7 +15113,7 @@
return true
}
}
-func rewriteValueARM_OpMod16u(v *Value) bool {
+func rewriteValueARM_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15079,7 +15134,7 @@
return true
}
}
-func rewriteValueARM_OpMod32(v *Value) bool {
+func rewriteValueARM_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15128,7 +15183,7 @@
return true
}
}
-func rewriteValueARM_OpMod32u(v *Value) bool {
+func rewriteValueARM_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15148,7 +15203,7 @@
return true
}
}
-func rewriteValueARM_OpMod8(v *Value) bool {
+func rewriteValueARM_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15169,7 +15224,7 @@
return true
}
}
-func rewriteValueARM_OpMod8u(v *Value) bool {
+func rewriteValueARM_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15190,7 +15245,7 @@
return true
}
}
-func rewriteValueARM_OpMove(v *Value) bool {
+func rewriteValueARM_OpMove_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -15462,7 +15517,7 @@
}
return false
}
-func rewriteValueARM_OpMul16(v *Value) bool {
+func rewriteValueARM_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MUL x y)
@@ -15475,7 +15530,7 @@
return true
}
}
-func rewriteValueARM_OpMul32(v *Value) bool {
+func rewriteValueARM_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MUL x y)
@@ -15488,7 +15543,7 @@
return true
}
}
-func rewriteValueARM_OpMul32F(v *Value) bool {
+func rewriteValueARM_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
@@ -15501,7 +15556,7 @@
return true
}
}
-func rewriteValueARM_OpMul32uhilo(v *Value) bool {
+func rewriteValueARM_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULLU x y)
@@ -15514,7 +15569,7 @@
return true
}
}
-func rewriteValueARM_OpMul64F(v *Value) bool {
+func rewriteValueARM_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
@@ -15527,7 +15582,7 @@
return true
}
}
-func rewriteValueARM_OpMul8(v *Value) bool {
+func rewriteValueARM_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MUL x y)
@@ -15540,7 +15595,7 @@
return true
}
}
-func rewriteValueARM_OpNeg16(v *Value) bool {
+func rewriteValueARM_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (RSBconst [0] x)
@@ -15552,7 +15607,7 @@
return true
}
}
-func rewriteValueARM_OpNeg32(v *Value) bool {
+func rewriteValueARM_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (RSBconst [0] x)
@@ -15564,7 +15619,7 @@
return true
}
}
-func rewriteValueARM_OpNeg32F(v *Value) bool {
+func rewriteValueARM_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
@@ -15575,7 +15630,7 @@
return true
}
}
-func rewriteValueARM_OpNeg64F(v *Value) bool {
+func rewriteValueARM_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
@@ -15586,7 +15641,7 @@
return true
}
}
-func rewriteValueARM_OpNeg8(v *Value) bool {
+func rewriteValueARM_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (RSBconst [0] x)
@@ -15598,7 +15653,7 @@
return true
}
}
-func rewriteValueARM_OpNeq16(v *Value) bool {
+func rewriteValueARM_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15621,7 +15676,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32(v *Value) bool {
+func rewriteValueARM_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
@@ -15638,7 +15693,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32F(v *Value) bool {
+func rewriteValueARM_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -15655,7 +15710,7 @@
return true
}
}
-func rewriteValueARM_OpNeq64F(v *Value) bool {
+func rewriteValueARM_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -15672,7 +15727,7 @@
return true
}
}
-func rewriteValueARM_OpNeq8(v *Value) bool {
+func rewriteValueARM_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15695,7 +15750,7 @@
return true
}
}
-func rewriteValueARM_OpNeqB(v *Value) bool {
+func rewriteValueARM_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
@@ -15708,7 +15763,7 @@
return true
}
}
-func rewriteValueARM_OpNeqPtr(v *Value) bool {
+func rewriteValueARM_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
@@ -15725,7 +15780,7 @@
return true
}
}
-func rewriteValueARM_OpNilCheck(v *Value) bool {
+func rewriteValueARM_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -15738,7 +15793,7 @@
return true
}
}
-func rewriteValueARM_OpNot(v *Value) bool {
+func rewriteValueARM_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
@@ -15750,7 +15805,7 @@
return true
}
}
-func rewriteValueARM_OpOffPtr(v *Value) bool {
+func rewriteValueARM_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVWaddr [off] ptr)
@@ -15777,7 +15832,7 @@
return true
}
}
-func rewriteValueARM_OpOr16(v *Value) bool {
+func rewriteValueARM_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
@@ -15790,7 +15845,7 @@
return true
}
}
-func rewriteValueARM_OpOr32(v *Value) bool {
+func rewriteValueARM_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
@@ -15803,7 +15858,7 @@
return true
}
}
-func rewriteValueARM_OpOr8(v *Value) bool {
+func rewriteValueARM_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
@@ -15816,7 +15871,7 @@
return true
}
}
-func rewriteValueARM_OpOrB(v *Value) bool {
+func rewriteValueARM_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
@@ -15829,7 +15884,7 @@
return true
}
}
-func rewriteValueARM_OpRound32F(v *Value) bool {
+func rewriteValueARM_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
@@ -15841,7 +15896,7 @@
return true
}
}
-func rewriteValueARM_OpRound64F(v *Value) bool {
+func rewriteValueARM_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
@@ -15853,7 +15908,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15883,7 +15938,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15909,7 +15964,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15953,7 +16008,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -15974,7 +16029,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x16(v *Value) bool {
+func rewriteValueARM_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16001,7 +16056,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x32(v *Value) bool {
+func rewriteValueARM_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16024,7 +16079,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x64(v *Value) bool {
+func rewriteValueARM_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16073,7 +16128,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16x8(v *Value) bool {
+func rewriteValueARM_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16094,7 +16149,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16122,7 +16177,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 x y)
@@ -16144,7 +16199,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRLconst x [c])
@@ -16181,7 +16236,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16200,7 +16255,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x16(v *Value) bool {
+func rewriteValueARM_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16225,7 +16280,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x32(v *Value) bool {
+func rewriteValueARM_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 x y)
@@ -16244,7 +16299,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x64(v *Value) bool {
+func rewriteValueARM_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRAconst x [c])
@@ -16283,7 +16338,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32x8(v *Value) bool {
+func rewriteValueARM_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16302,7 +16357,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16332,7 +16387,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16358,7 +16413,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16402,7 +16457,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16423,7 +16478,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x16(v *Value) bool {
+func rewriteValueARM_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16450,7 +16505,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x32(v *Value) bool {
+func rewriteValueARM_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16473,7 +16528,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x64(v *Value) bool {
+func rewriteValueARM_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16522,7 +16577,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8x8(v *Value) bool {
+func rewriteValueARM_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -16543,7 +16598,7 @@
return true
}
}
-func rewriteValueARM_OpSelect0(v *Value) bool {
+func rewriteValueARM_OpSelect0_0(v *Value) bool {
// match: (Select0 (CALLudiv x (MOVWconst [1])))
// cond:
// result: x
@@ -16611,7 +16666,7 @@
}
return false
}
-func rewriteValueARM_OpSelect1(v *Value) bool {
+func rewriteValueARM_OpSelect1_0(v *Value) bool {
// match: (Select1 (CALLudiv _ (MOVWconst [1])))
// cond:
// result: (MOVWconst [0])
@@ -16677,7 +16732,7 @@
}
return false
}
-func rewriteValueARM_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
@@ -16688,7 +16743,7 @@
return true
}
}
-func rewriteValueARM_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
@@ -16699,7 +16754,7 @@
return true
}
}
-func rewriteValueARM_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
@@ -16710,7 +16765,7 @@
return true
}
}
-func rewriteValueARM_OpSignmask(v *Value) bool {
+func rewriteValueARM_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SRAconst x [31])
@@ -16722,7 +16777,7 @@
return true
}
}
-func rewriteValueARM_OpSlicemask(v *Value) bool {
+func rewriteValueARM_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -16740,7 +16795,7 @@
return true
}
}
-func rewriteValueARM_OpSqrt(v *Value) bool {
+func rewriteValueARM_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTD x)
@@ -16751,7 +16806,7 @@
return true
}
}
-func rewriteValueARM_OpStaticCall(v *Value) bool {
+func rewriteValueARM_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -16766,7 +16821,7 @@
return true
}
}
-func rewriteValueARM_OpStore(v *Value) bool {
+func rewriteValueARM_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
@@ -16854,7 +16909,7 @@
}
return false
}
-func rewriteValueARM_OpSub16(v *Value) bool {
+func rewriteValueARM_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
@@ -16867,7 +16922,7 @@
return true
}
}
-func rewriteValueARM_OpSub32(v *Value) bool {
+func rewriteValueARM_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
@@ -16880,7 +16935,7 @@
return true
}
}
-func rewriteValueARM_OpSub32F(v *Value) bool {
+func rewriteValueARM_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
@@ -16893,7 +16948,7 @@
return true
}
}
-func rewriteValueARM_OpSub32carry(v *Value) bool {
+func rewriteValueARM_OpSub32carry_0(v *Value) bool {
// match: (Sub32carry x y)
// cond:
// result: (SUBS x y)
@@ -16906,7 +16961,7 @@
return true
}
}
-func rewriteValueARM_OpSub32withcarry(v *Value) bool {
+func rewriteValueARM_OpSub32withcarry_0(v *Value) bool {
// match: (Sub32withcarry x y c)
// cond:
// result: (SBC x y c)
@@ -16921,7 +16976,7 @@
return true
}
}
-func rewriteValueARM_OpSub64F(v *Value) bool {
+func rewriteValueARM_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
@@ -16934,7 +16989,7 @@
return true
}
}
-func rewriteValueARM_OpSub8(v *Value) bool {
+func rewriteValueARM_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
@@ -16947,7 +17002,7 @@
return true
}
}
-func rewriteValueARM_OpSubPtr(v *Value) bool {
+func rewriteValueARM_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
@@ -16960,7 +17015,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -16972,7 +17027,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -16984,7 +17039,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -16996,7 +17051,7 @@
return true
}
}
-func rewriteValueARM_OpXor16(v *Value) bool {
+func rewriteValueARM_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
@@ -17009,7 +17064,7 @@
return true
}
}
-func rewriteValueARM_OpXor32(v *Value) bool {
+func rewriteValueARM_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
@@ -17022,7 +17077,7 @@
return true
}
}
-func rewriteValueARM_OpXor8(v *Value) bool {
+func rewriteValueARM_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
@@ -17035,7 +17090,7 @@
return true
}
}
-func rewriteValueARM_OpZero(v *Value) bool {
+func rewriteValueARM_OpZero_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
@@ -17285,7 +17340,7 @@
}
return false
}
-func rewriteValueARM_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
@@ -17296,7 +17351,7 @@
return true
}
}
-func rewriteValueARM_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
@@ -17307,7 +17362,7 @@
return true
}
}
-func rewriteValueARM_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
@@ -17318,7 +17373,7 @@
return true
}
}
-func rewriteValueARM_OpZeromask(v *Value) bool {
+func rewriteValueARM_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 56f5ab5..684961b 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -14,711 +14,711 @@
func rewriteValueARM64(v *Value) bool {
switch v.Op {
case OpARM64ADD:
- return rewriteValueARM64_OpARM64ADD(v)
+ return rewriteValueARM64_OpARM64ADD_0(v)
case OpARM64ADDconst:
- return rewriteValueARM64_OpARM64ADDconst(v)
+ return rewriteValueARM64_OpARM64ADDconst_0(v)
case OpARM64ADDshiftLL:
- return rewriteValueARM64_OpARM64ADDshiftLL(v)
+ return rewriteValueARM64_OpARM64ADDshiftLL_0(v)
case OpARM64ADDshiftRA:
- return rewriteValueARM64_OpARM64ADDshiftRA(v)
+ return rewriteValueARM64_OpARM64ADDshiftRA_0(v)
case OpARM64ADDshiftRL:
- return rewriteValueARM64_OpARM64ADDshiftRL(v)
+ return rewriteValueARM64_OpARM64ADDshiftRL_0(v)
case OpARM64AND:
- return rewriteValueARM64_OpARM64AND(v)
+ return rewriteValueARM64_OpARM64AND_0(v) || rewriteValueARM64_OpARM64AND_10(v)
case OpARM64ANDconst:
- return rewriteValueARM64_OpARM64ANDconst(v)
+ return rewriteValueARM64_OpARM64ANDconst_0(v)
case OpARM64ANDshiftLL:
- return rewriteValueARM64_OpARM64ANDshiftLL(v)
+ return rewriteValueARM64_OpARM64ANDshiftLL_0(v)
case OpARM64ANDshiftRA:
- return rewriteValueARM64_OpARM64ANDshiftRA(v)
+ return rewriteValueARM64_OpARM64ANDshiftRA_0(v)
case OpARM64ANDshiftRL:
- return rewriteValueARM64_OpARM64ANDshiftRL(v)
+ return rewriteValueARM64_OpARM64ANDshiftRL_0(v)
case OpARM64BIC:
- return rewriteValueARM64_OpARM64BIC(v)
+ return rewriteValueARM64_OpARM64BIC_0(v)
case OpARM64BICconst:
- return rewriteValueARM64_OpARM64BICconst(v)
+ return rewriteValueARM64_OpARM64BICconst_0(v)
case OpARM64BICshiftLL:
- return rewriteValueARM64_OpARM64BICshiftLL(v)
+ return rewriteValueARM64_OpARM64BICshiftLL_0(v)
case OpARM64BICshiftRA:
- return rewriteValueARM64_OpARM64BICshiftRA(v)
+ return rewriteValueARM64_OpARM64BICshiftRA_0(v)
case OpARM64BICshiftRL:
- return rewriteValueARM64_OpARM64BICshiftRL(v)
+ return rewriteValueARM64_OpARM64BICshiftRL_0(v)
case OpARM64CMP:
- return rewriteValueARM64_OpARM64CMP(v)
+ return rewriteValueARM64_OpARM64CMP_0(v)
case OpARM64CMPW:
- return rewriteValueARM64_OpARM64CMPW(v)
+ return rewriteValueARM64_OpARM64CMPW_0(v)
case OpARM64CMPWconst:
- return rewriteValueARM64_OpARM64CMPWconst(v)
+ return rewriteValueARM64_OpARM64CMPWconst_0(v)
case OpARM64CMPconst:
- return rewriteValueARM64_OpARM64CMPconst(v)
+ return rewriteValueARM64_OpARM64CMPconst_0(v)
case OpARM64CMPshiftLL:
- return rewriteValueARM64_OpARM64CMPshiftLL(v)
+ return rewriteValueARM64_OpARM64CMPshiftLL_0(v)
case OpARM64CMPshiftRA:
- return rewriteValueARM64_OpARM64CMPshiftRA(v)
+ return rewriteValueARM64_OpARM64CMPshiftRA_0(v)
case OpARM64CMPshiftRL:
- return rewriteValueARM64_OpARM64CMPshiftRL(v)
+ return rewriteValueARM64_OpARM64CMPshiftRL_0(v)
case OpARM64CSELULT:
- return rewriteValueARM64_OpARM64CSELULT(v)
+ return rewriteValueARM64_OpARM64CSELULT_0(v)
case OpARM64CSELULT0:
- return rewriteValueARM64_OpARM64CSELULT0(v)
+ return rewriteValueARM64_OpARM64CSELULT0_0(v)
case OpARM64DIV:
- return rewriteValueARM64_OpARM64DIV(v)
+ return rewriteValueARM64_OpARM64DIV_0(v)
case OpARM64DIVW:
- return rewriteValueARM64_OpARM64DIVW(v)
+ return rewriteValueARM64_OpARM64DIVW_0(v)
case OpARM64Equal:
- return rewriteValueARM64_OpARM64Equal(v)
+ return rewriteValueARM64_OpARM64Equal_0(v)
case OpARM64FMOVDload:
- return rewriteValueARM64_OpARM64FMOVDload(v)
+ return rewriteValueARM64_OpARM64FMOVDload_0(v)
case OpARM64FMOVDstore:
- return rewriteValueARM64_OpARM64FMOVDstore(v)
+ return rewriteValueARM64_OpARM64FMOVDstore_0(v)
case OpARM64FMOVSload:
- return rewriteValueARM64_OpARM64FMOVSload(v)
+ return rewriteValueARM64_OpARM64FMOVSload_0(v)
case OpARM64FMOVSstore:
- return rewriteValueARM64_OpARM64FMOVSstore(v)
+ return rewriteValueARM64_OpARM64FMOVSstore_0(v)
case OpARM64GreaterEqual:
- return rewriteValueARM64_OpARM64GreaterEqual(v)
+ return rewriteValueARM64_OpARM64GreaterEqual_0(v)
case OpARM64GreaterEqualU:
- return rewriteValueARM64_OpARM64GreaterEqualU(v)
+ return rewriteValueARM64_OpARM64GreaterEqualU_0(v)
case OpARM64GreaterThan:
- return rewriteValueARM64_OpARM64GreaterThan(v)
+ return rewriteValueARM64_OpARM64GreaterThan_0(v)
case OpARM64GreaterThanU:
- return rewriteValueARM64_OpARM64GreaterThanU(v)
+ return rewriteValueARM64_OpARM64GreaterThanU_0(v)
case OpARM64LessEqual:
- return rewriteValueARM64_OpARM64LessEqual(v)
+ return rewriteValueARM64_OpARM64LessEqual_0(v)
case OpARM64LessEqualU:
- return rewriteValueARM64_OpARM64LessEqualU(v)
+ return rewriteValueARM64_OpARM64LessEqualU_0(v)
case OpARM64LessThan:
- return rewriteValueARM64_OpARM64LessThan(v)
+ return rewriteValueARM64_OpARM64LessThan_0(v)
case OpARM64LessThanU:
- return rewriteValueARM64_OpARM64LessThanU(v)
+ return rewriteValueARM64_OpARM64LessThanU_0(v)
case OpARM64MOD:
- return rewriteValueARM64_OpARM64MOD(v)
+ return rewriteValueARM64_OpARM64MOD_0(v)
case OpARM64MODW:
- return rewriteValueARM64_OpARM64MODW(v)
+ return rewriteValueARM64_OpARM64MODW_0(v)
case OpARM64MOVBUload:
- return rewriteValueARM64_OpARM64MOVBUload(v)
+ return rewriteValueARM64_OpARM64MOVBUload_0(v)
case OpARM64MOVBUreg:
- return rewriteValueARM64_OpARM64MOVBUreg(v)
+ return rewriteValueARM64_OpARM64MOVBUreg_0(v)
case OpARM64MOVBload:
- return rewriteValueARM64_OpARM64MOVBload(v)
+ return rewriteValueARM64_OpARM64MOVBload_0(v)
case OpARM64MOVBreg:
- return rewriteValueARM64_OpARM64MOVBreg(v)
+ return rewriteValueARM64_OpARM64MOVBreg_0(v)
case OpARM64MOVBstore:
- return rewriteValueARM64_OpARM64MOVBstore(v)
+ return rewriteValueARM64_OpARM64MOVBstore_0(v)
case OpARM64MOVBstorezero:
- return rewriteValueARM64_OpARM64MOVBstorezero(v)
+ return rewriteValueARM64_OpARM64MOVBstorezero_0(v)
case OpARM64MOVDload:
- return rewriteValueARM64_OpARM64MOVDload(v)
+ return rewriteValueARM64_OpARM64MOVDload_0(v)
case OpARM64MOVDreg:
- return rewriteValueARM64_OpARM64MOVDreg(v)
+ return rewriteValueARM64_OpARM64MOVDreg_0(v)
case OpARM64MOVDstore:
- return rewriteValueARM64_OpARM64MOVDstore(v)
+ return rewriteValueARM64_OpARM64MOVDstore_0(v)
case OpARM64MOVDstorezero:
- return rewriteValueARM64_OpARM64MOVDstorezero(v)
+ return rewriteValueARM64_OpARM64MOVDstorezero_0(v)
case OpARM64MOVHUload:
- return rewriteValueARM64_OpARM64MOVHUload(v)
+ return rewriteValueARM64_OpARM64MOVHUload_0(v)
case OpARM64MOVHUreg:
- return rewriteValueARM64_OpARM64MOVHUreg(v)
+ return rewriteValueARM64_OpARM64MOVHUreg_0(v)
case OpARM64MOVHload:
- return rewriteValueARM64_OpARM64MOVHload(v)
+ return rewriteValueARM64_OpARM64MOVHload_0(v)
case OpARM64MOVHreg:
- return rewriteValueARM64_OpARM64MOVHreg(v)
+ return rewriteValueARM64_OpARM64MOVHreg_0(v)
case OpARM64MOVHstore:
- return rewriteValueARM64_OpARM64MOVHstore(v)
+ return rewriteValueARM64_OpARM64MOVHstore_0(v)
case OpARM64MOVHstorezero:
- return rewriteValueARM64_OpARM64MOVHstorezero(v)
+ return rewriteValueARM64_OpARM64MOVHstorezero_0(v)
case OpARM64MOVWUload:
- return rewriteValueARM64_OpARM64MOVWUload(v)
+ return rewriteValueARM64_OpARM64MOVWUload_0(v)
case OpARM64MOVWUreg:
- return rewriteValueARM64_OpARM64MOVWUreg(v)
+ return rewriteValueARM64_OpARM64MOVWUreg_0(v)
case OpARM64MOVWload:
- return rewriteValueARM64_OpARM64MOVWload(v)
+ return rewriteValueARM64_OpARM64MOVWload_0(v)
case OpARM64MOVWreg:
- return rewriteValueARM64_OpARM64MOVWreg(v)
+ return rewriteValueARM64_OpARM64MOVWreg_0(v) || rewriteValueARM64_OpARM64MOVWreg_10(v)
case OpARM64MOVWstore:
- return rewriteValueARM64_OpARM64MOVWstore(v)
+ return rewriteValueARM64_OpARM64MOVWstore_0(v)
case OpARM64MOVWstorezero:
- return rewriteValueARM64_OpARM64MOVWstorezero(v)
+ return rewriteValueARM64_OpARM64MOVWstorezero_0(v)
case OpARM64MUL:
- return rewriteValueARM64_OpARM64MUL(v)
+ return rewriteValueARM64_OpARM64MUL_0(v) || rewriteValueARM64_OpARM64MUL_10(v) || rewriteValueARM64_OpARM64MUL_20(v)
case OpARM64MULW:
- return rewriteValueARM64_OpARM64MULW(v)
+ return rewriteValueARM64_OpARM64MULW_0(v) || rewriteValueARM64_OpARM64MULW_10(v) || rewriteValueARM64_OpARM64MULW_20(v)
case OpARM64MVN:
- return rewriteValueARM64_OpARM64MVN(v)
+ return rewriteValueARM64_OpARM64MVN_0(v)
case OpARM64NEG:
- return rewriteValueARM64_OpARM64NEG(v)
+ return rewriteValueARM64_OpARM64NEG_0(v)
case OpARM64NotEqual:
- return rewriteValueARM64_OpARM64NotEqual(v)
+ return rewriteValueARM64_OpARM64NotEqual_0(v)
case OpARM64OR:
- return rewriteValueARM64_OpARM64OR(v)
+ return rewriteValueARM64_OpARM64OR_0(v) || rewriteValueARM64_OpARM64OR_10(v)
case OpARM64ORconst:
- return rewriteValueARM64_OpARM64ORconst(v)
+ return rewriteValueARM64_OpARM64ORconst_0(v)
case OpARM64ORshiftLL:
- return rewriteValueARM64_OpARM64ORshiftLL(v)
+ return rewriteValueARM64_OpARM64ORshiftLL_0(v) || rewriteValueARM64_OpARM64ORshiftLL_10(v)
case OpARM64ORshiftRA:
- return rewriteValueARM64_OpARM64ORshiftRA(v)
+ return rewriteValueARM64_OpARM64ORshiftRA_0(v)
case OpARM64ORshiftRL:
- return rewriteValueARM64_OpARM64ORshiftRL(v)
+ return rewriteValueARM64_OpARM64ORshiftRL_0(v)
case OpARM64SLL:
- return rewriteValueARM64_OpARM64SLL(v)
+ return rewriteValueARM64_OpARM64SLL_0(v)
case OpARM64SLLconst:
- return rewriteValueARM64_OpARM64SLLconst(v)
+ return rewriteValueARM64_OpARM64SLLconst_0(v)
case OpARM64SRA:
- return rewriteValueARM64_OpARM64SRA(v)
+ return rewriteValueARM64_OpARM64SRA_0(v)
case OpARM64SRAconst:
- return rewriteValueARM64_OpARM64SRAconst(v)
+ return rewriteValueARM64_OpARM64SRAconst_0(v)
case OpARM64SRL:
- return rewriteValueARM64_OpARM64SRL(v)
+ return rewriteValueARM64_OpARM64SRL_0(v)
case OpARM64SRLconst:
- return rewriteValueARM64_OpARM64SRLconst(v)
+ return rewriteValueARM64_OpARM64SRLconst_0(v)
case OpARM64SUB:
- return rewriteValueARM64_OpARM64SUB(v)
+ return rewriteValueARM64_OpARM64SUB_0(v)
case OpARM64SUBconst:
- return rewriteValueARM64_OpARM64SUBconst(v)
+ return rewriteValueARM64_OpARM64SUBconst_0(v)
case OpARM64SUBshiftLL:
- return rewriteValueARM64_OpARM64SUBshiftLL(v)
+ return rewriteValueARM64_OpARM64SUBshiftLL_0(v)
case OpARM64SUBshiftRA:
- return rewriteValueARM64_OpARM64SUBshiftRA(v)
+ return rewriteValueARM64_OpARM64SUBshiftRA_0(v)
case OpARM64SUBshiftRL:
- return rewriteValueARM64_OpARM64SUBshiftRL(v)
+ return rewriteValueARM64_OpARM64SUBshiftRL_0(v)
case OpARM64UDIV:
- return rewriteValueARM64_OpARM64UDIV(v)
+ return rewriteValueARM64_OpARM64UDIV_0(v)
case OpARM64UDIVW:
- return rewriteValueARM64_OpARM64UDIVW(v)
+ return rewriteValueARM64_OpARM64UDIVW_0(v)
case OpARM64UMOD:
- return rewriteValueARM64_OpARM64UMOD(v)
+ return rewriteValueARM64_OpARM64UMOD_0(v)
case OpARM64UMODW:
- return rewriteValueARM64_OpARM64UMODW(v)
+ return rewriteValueARM64_OpARM64UMODW_0(v)
case OpARM64XOR:
- return rewriteValueARM64_OpARM64XOR(v)
+ return rewriteValueARM64_OpARM64XOR_0(v)
case OpARM64XORconst:
- return rewriteValueARM64_OpARM64XORconst(v)
+ return rewriteValueARM64_OpARM64XORconst_0(v)
case OpARM64XORshiftLL:
- return rewriteValueARM64_OpARM64XORshiftLL(v)
+ return rewriteValueARM64_OpARM64XORshiftLL_0(v)
case OpARM64XORshiftRA:
- return rewriteValueARM64_OpARM64XORshiftRA(v)
+ return rewriteValueARM64_OpARM64XORshiftRA_0(v)
case OpARM64XORshiftRL:
- return rewriteValueARM64_OpARM64XORshiftRL(v)
+ return rewriteValueARM64_OpARM64XORshiftRL_0(v)
case OpAdd16:
- return rewriteValueARM64_OpAdd16(v)
+ return rewriteValueARM64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueARM64_OpAdd32(v)
+ return rewriteValueARM64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueARM64_OpAdd32F(v)
+ return rewriteValueARM64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueARM64_OpAdd64(v)
+ return rewriteValueARM64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueARM64_OpAdd64F(v)
+ return rewriteValueARM64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueARM64_OpAdd8(v)
+ return rewriteValueARM64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueARM64_OpAddPtr(v)
+ return rewriteValueARM64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueARM64_OpAddr(v)
+ return rewriteValueARM64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueARM64_OpAnd16(v)
+ return rewriteValueARM64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueARM64_OpAnd32(v)
+ return rewriteValueARM64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueARM64_OpAnd64(v)
+ return rewriteValueARM64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueARM64_OpAnd8(v)
+ return rewriteValueARM64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueARM64_OpAndB(v)
+ return rewriteValueARM64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueARM64_OpAtomicAdd32(v)
+ return rewriteValueARM64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueARM64_OpAtomicAdd64(v)
+ return rewriteValueARM64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValueARM64_OpAtomicAnd8(v)
+ return rewriteValueARM64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueARM64_OpAtomicCompareAndSwap32(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueARM64_OpAtomicCompareAndSwap64(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueARM64_OpAtomicExchange32(v)
+ return rewriteValueARM64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueARM64_OpAtomicExchange64(v)
+ return rewriteValueARM64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueARM64_OpAtomicLoad32(v)
+ return rewriteValueARM64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueARM64_OpAtomicLoad64(v)
+ return rewriteValueARM64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueARM64_OpAtomicLoadPtr(v)
+ return rewriteValueARM64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValueARM64_OpAtomicOr8(v)
+ return rewriteValueARM64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValueARM64_OpAtomicStore32(v)
+ return rewriteValueARM64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueARM64_OpAtomicStore64(v)
+ return rewriteValueARM64_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueARM64_OpAtomicStorePtrNoWB(v)
+ return rewriteValueARM64_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueARM64_OpAvg64u(v)
+ return rewriteValueARM64_OpAvg64u_0(v)
case OpBitLen64:
- return rewriteValueARM64_OpBitLen64(v)
+ return rewriteValueARM64_OpBitLen64_0(v)
case OpBitRev16:
- return rewriteValueARM64_OpBitRev16(v)
+ return rewriteValueARM64_OpBitRev16_0(v)
case OpBitRev32:
- return rewriteValueARM64_OpBitRev32(v)
+ return rewriteValueARM64_OpBitRev32_0(v)
case OpBitRev64:
- return rewriteValueARM64_OpBitRev64(v)
+ return rewriteValueARM64_OpBitRev64_0(v)
case OpBitRev8:
- return rewriteValueARM64_OpBitRev8(v)
+ return rewriteValueARM64_OpBitRev8_0(v)
case OpBswap32:
- return rewriteValueARM64_OpBswap32(v)
+ return rewriteValueARM64_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueARM64_OpBswap64(v)
+ return rewriteValueARM64_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueARM64_OpClosureCall(v)
+ return rewriteValueARM64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueARM64_OpCom16(v)
+ return rewriteValueARM64_OpCom16_0(v)
case OpCom32:
- return rewriteValueARM64_OpCom32(v)
+ return rewriteValueARM64_OpCom32_0(v)
case OpCom64:
- return rewriteValueARM64_OpCom64(v)
+ return rewriteValueARM64_OpCom64_0(v)
case OpCom8:
- return rewriteValueARM64_OpCom8(v)
+ return rewriteValueARM64_OpCom8_0(v)
case OpConst16:
- return rewriteValueARM64_OpConst16(v)
+ return rewriteValueARM64_OpConst16_0(v)
case OpConst32:
- return rewriteValueARM64_OpConst32(v)
+ return rewriteValueARM64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueARM64_OpConst32F(v)
+ return rewriteValueARM64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueARM64_OpConst64(v)
+ return rewriteValueARM64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueARM64_OpConst64F(v)
+ return rewriteValueARM64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueARM64_OpConst8(v)
+ return rewriteValueARM64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueARM64_OpConstBool(v)
+ return rewriteValueARM64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueARM64_OpConstNil(v)
+ return rewriteValueARM64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueARM64_OpConvert(v)
+ return rewriteValueARM64_OpConvert_0(v)
case OpCtz32:
- return rewriteValueARM64_OpCtz32(v)
+ return rewriteValueARM64_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueARM64_OpCtz64(v)
+ return rewriteValueARM64_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueARM64_OpCvt32Fto32(v)
+ return rewriteValueARM64_OpCvt32Fto32_0(v)
case OpCvt32Fto32U:
- return rewriteValueARM64_OpCvt32Fto32U(v)
+ return rewriteValueARM64_OpCvt32Fto32U_0(v)
case OpCvt32Fto64:
- return rewriteValueARM64_OpCvt32Fto64(v)
+ return rewriteValueARM64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueARM64_OpCvt32Fto64F(v)
+ return rewriteValueARM64_OpCvt32Fto64F_0(v)
case OpCvt32Fto64U:
- return rewriteValueARM64_OpCvt32Fto64U(v)
+ return rewriteValueARM64_OpCvt32Fto64U_0(v)
case OpCvt32Uto32F:
- return rewriteValueARM64_OpCvt32Uto32F(v)
+ return rewriteValueARM64_OpCvt32Uto32F_0(v)
case OpCvt32Uto64F:
- return rewriteValueARM64_OpCvt32Uto64F(v)
+ return rewriteValueARM64_OpCvt32Uto64F_0(v)
case OpCvt32to32F:
- return rewriteValueARM64_OpCvt32to32F(v)
+ return rewriteValueARM64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueARM64_OpCvt32to64F(v)
+ return rewriteValueARM64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueARM64_OpCvt64Fto32(v)
+ return rewriteValueARM64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueARM64_OpCvt64Fto32F(v)
+ return rewriteValueARM64_OpCvt64Fto32F_0(v)
case OpCvt64Fto32U:
- return rewriteValueARM64_OpCvt64Fto32U(v)
+ return rewriteValueARM64_OpCvt64Fto32U_0(v)
case OpCvt64Fto64:
- return rewriteValueARM64_OpCvt64Fto64(v)
+ return rewriteValueARM64_OpCvt64Fto64_0(v)
case OpCvt64Fto64U:
- return rewriteValueARM64_OpCvt64Fto64U(v)
+ return rewriteValueARM64_OpCvt64Fto64U_0(v)
case OpCvt64Uto32F:
- return rewriteValueARM64_OpCvt64Uto32F(v)
+ return rewriteValueARM64_OpCvt64Uto32F_0(v)
case OpCvt64Uto64F:
- return rewriteValueARM64_OpCvt64Uto64F(v)
+ return rewriteValueARM64_OpCvt64Uto64F_0(v)
case OpCvt64to32F:
- return rewriteValueARM64_OpCvt64to32F(v)
+ return rewriteValueARM64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueARM64_OpCvt64to64F(v)
+ return rewriteValueARM64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueARM64_OpDiv16(v)
+ return rewriteValueARM64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueARM64_OpDiv16u(v)
+ return rewriteValueARM64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueARM64_OpDiv32(v)
+ return rewriteValueARM64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueARM64_OpDiv32F(v)
+ return rewriteValueARM64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueARM64_OpDiv32u(v)
+ return rewriteValueARM64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueARM64_OpDiv64(v)
+ return rewriteValueARM64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueARM64_OpDiv64F(v)
+ return rewriteValueARM64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueARM64_OpDiv64u(v)
+ return rewriteValueARM64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueARM64_OpDiv8(v)
+ return rewriteValueARM64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueARM64_OpDiv8u(v)
+ return rewriteValueARM64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueARM64_OpEq16(v)
+ return rewriteValueARM64_OpEq16_0(v)
case OpEq32:
- return rewriteValueARM64_OpEq32(v)
+ return rewriteValueARM64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueARM64_OpEq32F(v)
+ return rewriteValueARM64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueARM64_OpEq64(v)
+ return rewriteValueARM64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueARM64_OpEq64F(v)
+ return rewriteValueARM64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueARM64_OpEq8(v)
+ return rewriteValueARM64_OpEq8_0(v)
case OpEqB:
- return rewriteValueARM64_OpEqB(v)
+ return rewriteValueARM64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueARM64_OpEqPtr(v)
+ return rewriteValueARM64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueARM64_OpGeq16(v)
+ return rewriteValueARM64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueARM64_OpGeq16U(v)
+ return rewriteValueARM64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueARM64_OpGeq32(v)
+ return rewriteValueARM64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueARM64_OpGeq32F(v)
+ return rewriteValueARM64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueARM64_OpGeq32U(v)
+ return rewriteValueARM64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueARM64_OpGeq64(v)
+ return rewriteValueARM64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueARM64_OpGeq64F(v)
+ return rewriteValueARM64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueARM64_OpGeq64U(v)
+ return rewriteValueARM64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueARM64_OpGeq8(v)
+ return rewriteValueARM64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueARM64_OpGeq8U(v)
+ return rewriteValueARM64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueARM64_OpGetClosurePtr(v)
+ return rewriteValueARM64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueARM64_OpGreater16(v)
+ return rewriteValueARM64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueARM64_OpGreater16U(v)
+ return rewriteValueARM64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueARM64_OpGreater32(v)
+ return rewriteValueARM64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueARM64_OpGreater32F(v)
+ return rewriteValueARM64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueARM64_OpGreater32U(v)
+ return rewriteValueARM64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueARM64_OpGreater64(v)
+ return rewriteValueARM64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueARM64_OpGreater64F(v)
+ return rewriteValueARM64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueARM64_OpGreater64U(v)
+ return rewriteValueARM64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueARM64_OpGreater8(v)
+ return rewriteValueARM64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueARM64_OpGreater8U(v)
+ return rewriteValueARM64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueARM64_OpHmul32(v)
+ return rewriteValueARM64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueARM64_OpHmul32u(v)
+ return rewriteValueARM64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueARM64_OpHmul64(v)
+ return rewriteValueARM64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueARM64_OpHmul64u(v)
+ return rewriteValueARM64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValueARM64_OpInterCall(v)
+ return rewriteValueARM64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueARM64_OpIsInBounds(v)
+ return rewriteValueARM64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueARM64_OpIsNonNil(v)
+ return rewriteValueARM64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueARM64_OpIsSliceInBounds(v)
+ return rewriteValueARM64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueARM64_OpLeq16(v)
+ return rewriteValueARM64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueARM64_OpLeq16U(v)
+ return rewriteValueARM64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueARM64_OpLeq32(v)
+ return rewriteValueARM64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueARM64_OpLeq32F(v)
+ return rewriteValueARM64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueARM64_OpLeq32U(v)
+ return rewriteValueARM64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueARM64_OpLeq64(v)
+ return rewriteValueARM64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueARM64_OpLeq64F(v)
+ return rewriteValueARM64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueARM64_OpLeq64U(v)
+ return rewriteValueARM64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueARM64_OpLeq8(v)
+ return rewriteValueARM64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueARM64_OpLeq8U(v)
+ return rewriteValueARM64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueARM64_OpLess16(v)
+ return rewriteValueARM64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueARM64_OpLess16U(v)
+ return rewriteValueARM64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueARM64_OpLess32(v)
+ return rewriteValueARM64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueARM64_OpLess32F(v)
+ return rewriteValueARM64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueARM64_OpLess32U(v)
+ return rewriteValueARM64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueARM64_OpLess64(v)
+ return rewriteValueARM64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueARM64_OpLess64F(v)
+ return rewriteValueARM64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueARM64_OpLess64U(v)
+ return rewriteValueARM64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueARM64_OpLess8(v)
+ return rewriteValueARM64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueARM64_OpLess8U(v)
+ return rewriteValueARM64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueARM64_OpLoad(v)
+ return rewriteValueARM64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueARM64_OpLsh16x16(v)
+ return rewriteValueARM64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueARM64_OpLsh16x32(v)
+ return rewriteValueARM64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueARM64_OpLsh16x64(v)
+ return rewriteValueARM64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueARM64_OpLsh16x8(v)
+ return rewriteValueARM64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueARM64_OpLsh32x16(v)
+ return rewriteValueARM64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueARM64_OpLsh32x32(v)
+ return rewriteValueARM64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueARM64_OpLsh32x64(v)
+ return rewriteValueARM64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueARM64_OpLsh32x8(v)
+ return rewriteValueARM64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueARM64_OpLsh64x16(v)
+ return rewriteValueARM64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueARM64_OpLsh64x32(v)
+ return rewriteValueARM64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueARM64_OpLsh64x64(v)
+ return rewriteValueARM64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueARM64_OpLsh64x8(v)
+ return rewriteValueARM64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueARM64_OpLsh8x16(v)
+ return rewriteValueARM64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueARM64_OpLsh8x32(v)
+ return rewriteValueARM64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueARM64_OpLsh8x64(v)
+ return rewriteValueARM64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueARM64_OpLsh8x8(v)
+ return rewriteValueARM64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueARM64_OpMod16(v)
+ return rewriteValueARM64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueARM64_OpMod16u(v)
+ return rewriteValueARM64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueARM64_OpMod32(v)
+ return rewriteValueARM64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueARM64_OpMod32u(v)
+ return rewriteValueARM64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueARM64_OpMod64(v)
+ return rewriteValueARM64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueARM64_OpMod64u(v)
+ return rewriteValueARM64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueARM64_OpMod8(v)
+ return rewriteValueARM64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueARM64_OpMod8u(v)
+ return rewriteValueARM64_OpMod8u_0(v)
case OpMove:
- return rewriteValueARM64_OpMove(v)
+ return rewriteValueARM64_OpMove_0(v) || rewriteValueARM64_OpMove_10(v)
case OpMul16:
- return rewriteValueARM64_OpMul16(v)
+ return rewriteValueARM64_OpMul16_0(v)
case OpMul32:
- return rewriteValueARM64_OpMul32(v)
+ return rewriteValueARM64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueARM64_OpMul32F(v)
+ return rewriteValueARM64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueARM64_OpMul64(v)
+ return rewriteValueARM64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueARM64_OpMul64F(v)
+ return rewriteValueARM64_OpMul64F_0(v)
case OpMul8:
- return rewriteValueARM64_OpMul8(v)
+ return rewriteValueARM64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueARM64_OpNeg16(v)
+ return rewriteValueARM64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueARM64_OpNeg32(v)
+ return rewriteValueARM64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueARM64_OpNeg32F(v)
+ return rewriteValueARM64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueARM64_OpNeg64(v)
+ return rewriteValueARM64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueARM64_OpNeg64F(v)
+ return rewriteValueARM64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueARM64_OpNeg8(v)
+ return rewriteValueARM64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueARM64_OpNeq16(v)
+ return rewriteValueARM64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueARM64_OpNeq32(v)
+ return rewriteValueARM64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueARM64_OpNeq32F(v)
+ return rewriteValueARM64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueARM64_OpNeq64(v)
+ return rewriteValueARM64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueARM64_OpNeq64F(v)
+ return rewriteValueARM64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueARM64_OpNeq8(v)
+ return rewriteValueARM64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueARM64_OpNeqB(v)
+ return rewriteValueARM64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueARM64_OpNeqPtr(v)
+ return rewriteValueARM64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueARM64_OpNilCheck(v)
+ return rewriteValueARM64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueARM64_OpNot(v)
+ return rewriteValueARM64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueARM64_OpOffPtr(v)
+ return rewriteValueARM64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueARM64_OpOr16(v)
+ return rewriteValueARM64_OpOr16_0(v)
case OpOr32:
- return rewriteValueARM64_OpOr32(v)
+ return rewriteValueARM64_OpOr32_0(v)
case OpOr64:
- return rewriteValueARM64_OpOr64(v)
+ return rewriteValueARM64_OpOr64_0(v)
case OpOr8:
- return rewriteValueARM64_OpOr8(v)
+ return rewriteValueARM64_OpOr8_0(v)
case OpOrB:
- return rewriteValueARM64_OpOrB(v)
+ return rewriteValueARM64_OpOrB_0(v)
case OpRound32F:
- return rewriteValueARM64_OpRound32F(v)
+ return rewriteValueARM64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueARM64_OpRound64F(v)
+ return rewriteValueARM64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueARM64_OpRsh16Ux16(v)
+ return rewriteValueARM64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueARM64_OpRsh16Ux32(v)
+ return rewriteValueARM64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueARM64_OpRsh16Ux64(v)
+ return rewriteValueARM64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueARM64_OpRsh16Ux8(v)
+ return rewriteValueARM64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueARM64_OpRsh16x16(v)
+ return rewriteValueARM64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueARM64_OpRsh16x32(v)
+ return rewriteValueARM64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueARM64_OpRsh16x64(v)
+ return rewriteValueARM64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueARM64_OpRsh16x8(v)
+ return rewriteValueARM64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueARM64_OpRsh32Ux16(v)
+ return rewriteValueARM64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueARM64_OpRsh32Ux32(v)
+ return rewriteValueARM64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueARM64_OpRsh32Ux64(v)
+ return rewriteValueARM64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueARM64_OpRsh32Ux8(v)
+ return rewriteValueARM64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueARM64_OpRsh32x16(v)
+ return rewriteValueARM64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueARM64_OpRsh32x32(v)
+ return rewriteValueARM64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueARM64_OpRsh32x64(v)
+ return rewriteValueARM64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueARM64_OpRsh32x8(v)
+ return rewriteValueARM64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueARM64_OpRsh64Ux16(v)
+ return rewriteValueARM64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueARM64_OpRsh64Ux32(v)
+ return rewriteValueARM64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueARM64_OpRsh64Ux64(v)
+ return rewriteValueARM64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueARM64_OpRsh64Ux8(v)
+ return rewriteValueARM64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueARM64_OpRsh64x16(v)
+ return rewriteValueARM64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueARM64_OpRsh64x32(v)
+ return rewriteValueARM64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueARM64_OpRsh64x64(v)
+ return rewriteValueARM64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueARM64_OpRsh64x8(v)
+ return rewriteValueARM64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueARM64_OpRsh8Ux16(v)
+ return rewriteValueARM64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueARM64_OpRsh8Ux32(v)
+ return rewriteValueARM64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueARM64_OpRsh8Ux64(v)
+ return rewriteValueARM64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueARM64_OpRsh8Ux8(v)
+ return rewriteValueARM64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueARM64_OpRsh8x16(v)
+ return rewriteValueARM64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueARM64_OpRsh8x32(v)
+ return rewriteValueARM64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueARM64_OpRsh8x64(v)
+ return rewriteValueARM64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueARM64_OpRsh8x8(v)
+ return rewriteValueARM64_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValueARM64_OpSignExt16to32(v)
+ return rewriteValueARM64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueARM64_OpSignExt16to64(v)
+ return rewriteValueARM64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueARM64_OpSignExt32to64(v)
+ return rewriteValueARM64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueARM64_OpSignExt8to16(v)
+ return rewriteValueARM64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueARM64_OpSignExt8to32(v)
+ return rewriteValueARM64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueARM64_OpSignExt8to64(v)
+ return rewriteValueARM64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueARM64_OpSlicemask(v)
+ return rewriteValueARM64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueARM64_OpSqrt(v)
+ return rewriteValueARM64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueARM64_OpStaticCall(v)
+ return rewriteValueARM64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueARM64_OpStore(v)
+ return rewriteValueARM64_OpStore_0(v)
case OpSub16:
- return rewriteValueARM64_OpSub16(v)
+ return rewriteValueARM64_OpSub16_0(v)
case OpSub32:
- return rewriteValueARM64_OpSub32(v)
+ return rewriteValueARM64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueARM64_OpSub32F(v)
+ return rewriteValueARM64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueARM64_OpSub64(v)
+ return rewriteValueARM64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueARM64_OpSub64F(v)
+ return rewriteValueARM64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueARM64_OpSub8(v)
+ return rewriteValueARM64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueARM64_OpSubPtr(v)
+ return rewriteValueARM64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueARM64_OpTrunc16to8(v)
+ return rewriteValueARM64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueARM64_OpTrunc32to16(v)
+ return rewriteValueARM64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueARM64_OpTrunc32to8(v)
+ return rewriteValueARM64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueARM64_OpTrunc64to16(v)
+ return rewriteValueARM64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueARM64_OpTrunc64to32(v)
+ return rewriteValueARM64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueARM64_OpTrunc64to8(v)
+ return rewriteValueARM64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueARM64_OpXor16(v)
+ return rewriteValueARM64_OpXor16_0(v)
case OpXor32:
- return rewriteValueARM64_OpXor32(v)
+ return rewriteValueARM64_OpXor32_0(v)
case OpXor64:
- return rewriteValueARM64_OpXor64(v)
+ return rewriteValueARM64_OpXor64_0(v)
case OpXor8:
- return rewriteValueARM64_OpXor8(v)
+ return rewriteValueARM64_OpXor8_0(v)
case OpZero:
- return rewriteValueARM64_OpZero(v)
+ return rewriteValueARM64_OpZero_0(v) || rewriteValueARM64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueARM64_OpZeroExt16to32(v)
+ return rewriteValueARM64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueARM64_OpZeroExt16to64(v)
+ return rewriteValueARM64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueARM64_OpZeroExt32to64(v)
+ return rewriteValueARM64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueARM64_OpZeroExt8to16(v)
+ return rewriteValueARM64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueARM64_OpZeroExt8to32(v)
+ return rewriteValueARM64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueARM64_OpZeroExt8to64(v)
+ return rewriteValueARM64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueARM64_OpARM64ADD(v *Value) bool {
+func rewriteValueARM64_OpARM64ADD_0(v *Value) bool {
// match: (ADD x (MOVDconst [c]))
// cond:
// result: (ADDconst [c] x)
@@ -883,7 +883,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr))
// cond:
// result: (MOVDaddr [off1+off2] {sym} ptr)
@@ -963,7 +963,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLL (MOVDconst [c]) x [d])
@@ -1053,7 +1053,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRA (MOVDconst [c]) x [d])
@@ -1093,7 +1093,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRL (MOVDconst [c]) x [d])
@@ -1183,7 +1183,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64AND(v *Value) bool {
+func rewriteValueARM64_OpARM64AND_0(v *Value) bool {
// match: (AND x (MOVDconst [c]))
// cond:
// result: (ANDconst [c] x)
@@ -1342,6 +1342,9 @@
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64AND_10(v *Value) bool {
// match: (AND (SRAconst [c] y) x)
// cond:
// result: (ANDshiftRA x y [c])
@@ -1361,7 +1364,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVDconst [0])
@@ -1418,7 +1421,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLL (MOVDconst [c]) x [d])
@@ -1480,7 +1483,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRA (MOVDconst [c]) x [d])
@@ -1542,7 +1545,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRL (MOVDconst [c]) x [d])
@@ -1604,7 +1607,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BIC(v *Value) bool {
+func rewriteValueARM64_OpARM64BIC_0(v *Value) bool {
// match: (BIC x (MOVDconst [c]))
// cond:
// result: (BICconst [c] x)
@@ -1685,7 +1688,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICconst(v *Value) bool {
+func rewriteValueARM64_OpARM64BICconst_0(v *Value) bool {
// match: (BICconst [0] x)
// cond:
// result: x
@@ -1726,7 +1729,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftLL_0(v *Value) bool {
// match: (BICshiftLL x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint64(c)<<uint64(d))])
@@ -1766,7 +1769,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRA_0(v *Value) bool {
// match: (BICshiftRA x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(int64(c)>>uint64(d))])
@@ -1806,7 +1809,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool {
// match: (BICshiftRL x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint64(c)>>uint64(d))])
@@ -1846,7 +1849,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMP(v *Value) bool {
+func rewriteValueARM64_OpARM64CMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
@@ -1991,7 +1994,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVDconst [c]))
@@ -2028,7 +2031,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -2141,7 +2144,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
// result: (FlagEQ)
@@ -2301,7 +2304,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLL (MOVDconst [c]) x [d])
@@ -2343,7 +2346,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRA (MOVDconst [c]) x [d])
@@ -2385,7 +2388,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRL (MOVDconst [c]) x [d])
@@ -2427,7 +2430,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSELULT(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT_0(v *Value) bool {
// match: (CSELULT x (MOVDconst [0]) flag)
// cond:
// result: (CSELULT0 x flag)
@@ -2518,7 +2521,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT0_0(v *Value) bool {
// match: (CSELULT0 _ (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -2585,7 +2588,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIV(v *Value) bool {
+func rewriteValueARM64_OpARM64DIV_0(v *Value) bool {
// match: (DIV (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(c)/int64(d)])
@@ -2606,7 +2609,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool {
// match: (DIVW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)/int32(d))])
@@ -2627,7 +2630,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64Equal(v *Value) bool {
+func rewriteValueARM64_OpARM64Equal_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -2703,7 +2706,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (FMOVDload [off1+off2] {sym} ptr mem)
@@ -2753,7 +2756,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -2807,7 +2810,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (FMOVSload [off1+off2] {sym} ptr mem)
@@ -2857,7 +2860,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -2911,7 +2914,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -2987,7 +2990,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool {
// match: (GreaterEqualU (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -3063,7 +3066,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -3139,7 +3142,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool {
// match: (GreaterThanU (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -3215,7 +3218,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -3291,7 +3294,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool {
// match: (LessEqualU (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -3367,7 +3370,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -3443,7 +3446,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool {
// match: (LessThanU (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -3519,7 +3522,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOD(v *Value) bool {
+func rewriteValueARM64_OpARM64MOD_0(v *Value) bool {
// match: (MOD (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(c)%int64(d)])
@@ -3540,7 +3543,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MODW(v *Value) bool {
+func rewriteValueARM64_OpARM64MODW_0(v *Value) bool {
// match: (MODW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)%int32(d))])
@@ -3561,7 +3564,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -3632,7 +3635,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
@@ -3672,7 +3675,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -3743,7 +3746,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
@@ -3783,7 +3786,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -3985,7 +3988,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
@@ -4035,7 +4038,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDload [off1+off2] {sym} ptr mem)
@@ -4106,7 +4109,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool {
// match: (MOVDreg x)
// cond: x.Uses == 1
// result: (MOVDnop x)
@@ -4134,7 +4137,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -4210,7 +4213,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool {
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDstorezero [off1+off2] {sym} ptr mem)
@@ -4260,7 +4263,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -4331,7 +4334,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
@@ -4395,7 +4398,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -4466,7 +4469,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
@@ -4554,7 +4557,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -4714,7 +4717,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
@@ -4764,7 +4767,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool {
// match: (MOVWUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWUload [off1+off2] {sym} ptr mem)
@@ -4835,7 +4838,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool {
// match: (MOVWUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
@@ -4923,7 +4926,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWload [off1+off2] {sym} ptr mem)
@@ -4994,7 +4997,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
@@ -5115,6 +5118,9 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool {
// match: (MOVWreg (MOVDconst [c]))
// cond:
// result: (MOVDconst [int64(int32(c))])
@@ -5130,7 +5136,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
@@ -5248,7 +5254,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
@@ -5298,9 +5304,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MUL(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM64_OpARM64MUL_0(v *Value) bool {
// match: (MUL x (MOVDconst [-1]))
// cond:
// result: (NEG x)
@@ -5471,6 +5475,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MUL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MUL x (MOVDconst [c]))
// cond: isPowerOfTwo(c+1) && c >= 7
// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
@@ -5693,6 +5702,9 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MUL_20(v *Value) bool {
// match: (MUL (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [c*d])
@@ -5731,9 +5743,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MULW(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM64_OpARM64MULW_0(v *Value) bool {
// match: (MULW x (MOVDconst [c]))
// cond: int32(c)==-1
// result: (NEG x)
@@ -5910,6 +5920,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MULW_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULW x (MOVDconst [c]))
// cond: isPowerOfTwo(c+1) && int32(c) >= 7
// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
@@ -6132,6 +6147,9 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MULW_20(v *Value) bool {
// match: (MULW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)*int32(d))])
@@ -6170,7 +6188,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVN(v *Value) bool {
+func rewriteValueARM64_OpARM64MVN_0(v *Value) bool {
// match: (MVN (MOVDconst [c]))
// cond:
// result: (MOVDconst [^c])
@@ -6186,7 +6204,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEG(v *Value) bool {
+func rewriteValueARM64_OpARM64NEG_0(v *Value) bool {
// match: (NEG (MOVDconst [c]))
// cond:
// result: (MOVDconst [-c])
@@ -6202,7 +6220,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -6278,7 +6296,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64OR(v *Value) bool {
+func rewriteValueARM64_OpARM64OR_0(v *Value) bool {
b := v.Block
_ = b
// match: (OR x (MOVDconst [c]))
@@ -6533,6 +6551,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64OR_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (OR <t> y3:(MOVDnop x3:(MOVBUload [i0] {s} p mem)) o0:(ORshiftLL [8] o1:(ORshiftLL [16] s0:(SLLconst [24] y0:(MOVDnop x0:(MOVBUload [i3] {s} p mem))) y1:(MOVDnop x1:(MOVBUload [i2] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i1] {s} p mem))))
// cond: i1 == i0+1 && i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 && o0.Uses == 1 && o1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1,x2,x3) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) && clobber(o0) && clobber(o1) && clobber(s0)
// result: @mergePoint(b,x0,x1,x2,x3) (MOVWUload <t> {s} (OffPtr <p.Type> [i0] p) mem)
@@ -7696,7 +7719,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
@@ -7753,7 +7776,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLL (MOVDconst [c]) x [d])
@@ -8247,6 +8270,11 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORshiftLL <t> [56] o0:(ORshiftLL [48] o1:(ORshiftLL [40] o2:(ORshiftLL [32] y0:(REVW x0:(MOVWUload [i4] {s} p mem)) y1:(MOVDnop x1:(MOVBUload [i3] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i2] {s} p mem))) y3:(MOVDnop x3:(MOVBUload [i1] {s} p mem))) y4:(MOVDnop x4:(MOVBUload [i0] {s} p mem)))
// cond: i1 == i0+1 && i2 == i0+2 && i3 == i0+3 && i4 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && x4.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 && y4.Uses == 1 && o0.Uses == 1 && o1.Uses == 1 && o2.Uses == 1 && mergePoint(b,x0,x1,x2,x3,x4) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(x4) && clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) && clobber(y4) && clobber(o0) && clobber(o1) && clobber(o2)
// result: @mergePoint(b,x0,x1,x2,x3,x4) (REV <t> (MOVDload <t> {s} (OffPtr <p.Type> [i0] p) mem))
@@ -8379,7 +8407,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRA (MOVDconst [c]) x [d])
@@ -8441,7 +8469,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRL (MOVDconst [c]) x [d])
@@ -8553,7 +8581,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SLL_0(v *Value) bool {
// match: (SLL x (MOVDconst [c]))
// cond:
// result: (SLLconst x [c&63])
@@ -8571,7 +8599,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(d)<<uint64(c)])
@@ -8609,7 +8637,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SRA_0(v *Value) bool {
// match: (SRA x (MOVDconst [c]))
// cond:
// result: (SRAconst x [c&63])
@@ -8627,7 +8655,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(d)>>uint64(c)])
@@ -8644,7 +8672,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SRL_0(v *Value) bool {
// match: (SRL x (MOVDconst [c]))
// cond:
// result: (SRLconst x [c&63])
@@ -8662,7 +8690,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(uint64(d)>>uint64(c))])
@@ -8700,7 +8728,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUB(v *Value) bool {
+func rewriteValueARM64_OpARM64SUB_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUB x (MOVDconst [c]))
@@ -8821,7 +8849,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
@@ -8883,7 +8911,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftLL_0(v *Value) bool {
// match: (SUBshiftLL x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(uint64(c)<<uint64(d))])
@@ -8923,7 +8951,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRA_0(v *Value) bool {
// match: (SUBshiftRA x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(int64(c)>>uint64(d))])
@@ -8963,7 +8991,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool {
// match: (SUBshiftRL x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(uint64(c)>>uint64(d))])
@@ -9003,7 +9031,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool {
// match: (UDIV x (MOVDconst [1]))
// cond:
// result: x
@@ -9059,7 +9087,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool {
// match: (UDIVW x (MOVDconst [c]))
// cond: uint32(c)==1
// result: x
@@ -9116,7 +9144,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
+func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool {
// match: (UMOD _ (MOVDconst [1]))
// cond:
// result: (MOVDconst [0])
@@ -9170,7 +9198,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
+func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool {
// match: (UMODW _ (MOVDconst [c]))
// cond: uint32(c)==1
// result: (MOVDconst [0])
@@ -9225,7 +9253,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XOR(v *Value) bool {
+func rewriteValueARM64_OpARM64XOR_0(v *Value) bool {
// match: (XOR x (MOVDconst [c]))
// cond:
// result: (XORconst [c] x)
@@ -9372,7 +9400,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
@@ -9430,7 +9458,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLL (MOVDconst [c]) x [d])
@@ -9541,7 +9569,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRA (MOVDconst [c]) x [d])
@@ -9602,7 +9630,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRL (MOVDconst [c]) x [d])
@@ -9713,7 +9741,7 @@
}
return false
}
-func rewriteValueARM64_OpAdd16(v *Value) bool {
+func rewriteValueARM64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
@@ -9726,7 +9754,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd32(v *Value) bool {
+func rewriteValueARM64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
@@ -9739,7 +9767,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd32F(v *Value) bool {
+func rewriteValueARM64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
@@ -9752,7 +9780,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd64(v *Value) bool {
+func rewriteValueARM64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
@@ -9765,7 +9793,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd64F(v *Value) bool {
+func rewriteValueARM64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADDD x y)
@@ -9778,7 +9806,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd8(v *Value) bool {
+func rewriteValueARM64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
@@ -9791,7 +9819,7 @@
return true
}
}
-func rewriteValueARM64_OpAddPtr(v *Value) bool {
+func rewriteValueARM64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
@@ -9804,7 +9832,7 @@
return true
}
}
-func rewriteValueARM64_OpAddr(v *Value) bool {
+func rewriteValueARM64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
@@ -9817,7 +9845,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd16(v *Value) bool {
+func rewriteValueARM64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
@@ -9830,7 +9858,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd32(v *Value) bool {
+func rewriteValueARM64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
@@ -9843,7 +9871,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd64(v *Value) bool {
+func rewriteValueARM64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
@@ -9856,7 +9884,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd8(v *Value) bool {
+func rewriteValueARM64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
@@ -9869,7 +9897,7 @@
return true
}
}
-func rewriteValueARM64_OpAndB(v *Value) bool {
+func rewriteValueARM64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
@@ -9882,7 +9910,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd32 ptr val mem)
@@ -9897,7 +9925,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool {
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (LoweredAtomicAdd64 ptr val mem)
@@ -9912,7 +9940,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (LoweredAtomicAnd8 ptr val mem)
@@ -9927,7 +9955,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -9944,7 +9972,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -9961,7 +9989,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
@@ -9976,7 +10004,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
@@ -9991,7 +10019,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LDARW ptr mem)
@@ -10004,7 +10032,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (LDAR ptr mem)
@@ -10017,7 +10045,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LDAR ptr mem)
@@ -10030,7 +10058,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicOr8(v *Value) bool {
+func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (LoweredAtomicOr8 ptr val mem)
@@ -10045,7 +10073,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStore32(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (STLRW ptr val mem)
@@ -10060,7 +10088,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStore64(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (STLR ptr val mem)
@@ -10075,7 +10103,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (STLR ptr val mem)
@@ -10090,7 +10118,7 @@
return true
}
}
-func rewriteValueARM64_OpAvg64u(v *Value) bool {
+func rewriteValueARM64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
@@ -10112,7 +10140,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen64(v *Value) bool {
+func rewriteValueARM64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10132,7 +10160,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev16(v *Value) bool {
+func rewriteValueARM64_OpBitRev16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10150,7 +10178,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev32(v *Value) bool {
+func rewriteValueARM64_OpBitRev32_0(v *Value) bool {
// match: (BitRev32 x)
// cond:
// result: (RBITW x)
@@ -10161,7 +10189,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev64(v *Value) bool {
+func rewriteValueARM64_OpBitRev64_0(v *Value) bool {
// match: (BitRev64 x)
// cond:
// result: (RBIT x)
@@ -10172,7 +10200,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev8(v *Value) bool {
+func rewriteValueARM64_OpBitRev8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10190,7 +10218,7 @@
return true
}
}
-func rewriteValueARM64_OpBswap32(v *Value) bool {
+func rewriteValueARM64_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (REVW x)
@@ -10201,7 +10229,7 @@
return true
}
}
-func rewriteValueARM64_OpBswap64(v *Value) bool {
+func rewriteValueARM64_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (REV x)
@@ -10212,7 +10240,7 @@
return true
}
}
-func rewriteValueARM64_OpClosureCall(v *Value) bool {
+func rewriteValueARM64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -10229,7 +10257,7 @@
return true
}
}
-func rewriteValueARM64_OpCom16(v *Value) bool {
+func rewriteValueARM64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (MVN x)
@@ -10240,7 +10268,7 @@
return true
}
}
-func rewriteValueARM64_OpCom32(v *Value) bool {
+func rewriteValueARM64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (MVN x)
@@ -10251,7 +10279,7 @@
return true
}
}
-func rewriteValueARM64_OpCom64(v *Value) bool {
+func rewriteValueARM64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (MVN x)
@@ -10262,7 +10290,7 @@
return true
}
}
-func rewriteValueARM64_OpCom8(v *Value) bool {
+func rewriteValueARM64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (MVN x)
@@ -10273,7 +10301,7 @@
return true
}
}
-func rewriteValueARM64_OpConst16(v *Value) bool {
+func rewriteValueARM64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
@@ -10284,7 +10312,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32(v *Value) bool {
+func rewriteValueARM64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
@@ -10295,7 +10323,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32F(v *Value) bool {
+func rewriteValueARM64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
@@ -10306,7 +10334,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64(v *Value) bool {
+func rewriteValueARM64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
@@ -10317,7 +10345,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64F(v *Value) bool {
+func rewriteValueARM64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
@@ -10328,7 +10356,7 @@
return true
}
}
-func rewriteValueARM64_OpConst8(v *Value) bool {
+func rewriteValueARM64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
@@ -10339,7 +10367,7 @@
return true
}
}
-func rewriteValueARM64_OpConstBool(v *Value) bool {
+func rewriteValueARM64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
@@ -10350,7 +10378,7 @@
return true
}
}
-func rewriteValueARM64_OpConstNil(v *Value) bool {
+func rewriteValueARM64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
@@ -10360,7 +10388,7 @@
return true
}
}
-func rewriteValueARM64_OpConvert(v *Value) bool {
+func rewriteValueARM64_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVDconvert x mem)
@@ -10373,7 +10401,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz32(v *Value) bool {
+func rewriteValueARM64_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz32 <t> x)
@@ -10389,7 +10417,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz64(v *Value) bool {
+func rewriteValueARM64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz64 <t> x)
@@ -10405,7 +10433,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (FCVTZSSW x)
@@ -10416,7 +10444,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool {
// match: (Cvt32Fto32U x)
// cond:
// result: (FCVTZUSW x)
@@ -10427,7 +10455,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (FCVTZSS x)
@@ -10438,7 +10466,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (FCVTSD x)
@@ -10449,7 +10477,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool {
// match: (Cvt32Fto64U x)
// cond:
// result: (FCVTZUS x)
@@ -10460,7 +10488,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool {
// match: (Cvt32Uto32F x)
// cond:
// result: (UCVTFWS x)
@@ -10471,7 +10499,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool {
// match: (Cvt32Uto64F x)
// cond:
// result: (UCVTFWD x)
@@ -10482,7 +10510,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (SCVTFWS x)
@@ -10493,7 +10521,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (SCVTFWD x)
@@ -10504,7 +10532,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (FCVTZSDW x)
@@ -10515,7 +10543,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (FCVTDS x)
@@ -10526,7 +10554,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool {
// match: (Cvt64Fto32U x)
// cond:
// result: (FCVTZUDW x)
@@ -10537,7 +10565,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (FCVTZSD x)
@@ -10548,7 +10576,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool {
// match: (Cvt64Fto64U x)
// cond:
// result: (FCVTZUD x)
@@ -10559,7 +10587,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool {
// match: (Cvt64Uto32F x)
// cond:
// result: (UCVTFS x)
@@ -10570,7 +10598,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool {
// match: (Cvt64Uto64F x)
// cond:
// result: (UCVTFD x)
@@ -10581,7 +10609,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (SCVTFS x)
@@ -10592,7 +10620,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (SCVTFD x)
@@ -10603,7 +10631,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv16(v *Value) bool {
+func rewriteValueARM64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10624,7 +10652,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv16u(v *Value) bool {
+func rewriteValueARM64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10645,7 +10673,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32(v *Value) bool {
+func rewriteValueARM64_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVW x y)
@@ -10658,7 +10686,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32F(v *Value) bool {
+func rewriteValueARM64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
@@ -10671,7 +10699,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32u(v *Value) bool {
+func rewriteValueARM64_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (UDIVW x y)
@@ -10684,7 +10712,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64(v *Value) bool {
+func rewriteValueARM64_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIV x y)
@@ -10697,7 +10725,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64F(v *Value) bool {
+func rewriteValueARM64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIVD x y)
@@ -10710,7 +10738,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64u(v *Value) bool {
+func rewriteValueARM64_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (UDIV x y)
@@ -10723,7 +10751,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv8(v *Value) bool {
+func rewriteValueARM64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10744,7 +10772,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv8u(v *Value) bool {
+func rewriteValueARM64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10765,7 +10793,7 @@
return true
}
}
-func rewriteValueARM64_OpEq16(v *Value) bool {
+func rewriteValueARM64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10788,7 +10816,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32(v *Value) bool {
+func rewriteValueARM64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
@@ -10805,7 +10833,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32F(v *Value) bool {
+func rewriteValueARM64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -10822,7 +10850,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64(v *Value) bool {
+func rewriteValueARM64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
@@ -10839,7 +10867,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64F(v *Value) bool {
+func rewriteValueARM64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -10856,7 +10884,7 @@
return true
}
}
-func rewriteValueARM64_OpEq8(v *Value) bool {
+func rewriteValueARM64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10879,7 +10907,7 @@
return true
}
}
-func rewriteValueARM64_OpEqB(v *Value) bool {
+func rewriteValueARM64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10901,7 +10929,7 @@
return true
}
}
-func rewriteValueARM64_OpEqPtr(v *Value) bool {
+func rewriteValueARM64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
@@ -10918,7 +10946,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq16(v *Value) bool {
+func rewriteValueARM64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10941,7 +10969,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq16U(v *Value) bool {
+func rewriteValueARM64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -10964,7 +10992,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32(v *Value) bool {
+func rewriteValueARM64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
@@ -10981,7 +11009,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32F(v *Value) bool {
+func rewriteValueARM64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -10998,7 +11026,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32U(v *Value) bool {
+func rewriteValueARM64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
@@ -11015,7 +11043,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64(v *Value) bool {
+func rewriteValueARM64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
@@ -11032,7 +11060,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64F(v *Value) bool {
+func rewriteValueARM64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -11049,7 +11077,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64U(v *Value) bool {
+func rewriteValueARM64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
@@ -11066,7 +11094,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq8(v *Value) bool {
+func rewriteValueARM64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11089,7 +11117,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq8U(v *Value) bool {
+func rewriteValueARM64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11112,7 +11140,7 @@
return true
}
}
-func rewriteValueARM64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -11121,7 +11149,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater16(v *Value) bool {
+func rewriteValueARM64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11144,7 +11172,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater16U(v *Value) bool {
+func rewriteValueARM64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11167,7 +11195,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32(v *Value) bool {
+func rewriteValueARM64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
@@ -11184,7 +11212,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32F(v *Value) bool {
+func rewriteValueARM64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -11201,7 +11229,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32U(v *Value) bool {
+func rewriteValueARM64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
@@ -11218,7 +11246,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64(v *Value) bool {
+func rewriteValueARM64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
@@ -11235,7 +11263,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64F(v *Value) bool {
+func rewriteValueARM64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -11252,7 +11280,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64U(v *Value) bool {
+func rewriteValueARM64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
@@ -11269,7 +11297,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater8(v *Value) bool {
+func rewriteValueARM64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11292,7 +11320,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater8U(v *Value) bool {
+func rewriteValueARM64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11315,7 +11343,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32(v *Value) bool {
+func rewriteValueARM64_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11335,7 +11363,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32u(v *Value) bool {
+func rewriteValueARM64_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11355,7 +11383,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul64(v *Value) bool {
+func rewriteValueARM64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULH x y)
@@ -11368,7 +11396,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul64u(v *Value) bool {
+func rewriteValueARM64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (UMULH x y)
@@ -11381,7 +11409,7 @@
return true
}
}
-func rewriteValueARM64_OpInterCall(v *Value) bool {
+func rewriteValueARM64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -11396,7 +11424,7 @@
return true
}
}
-func rewriteValueARM64_OpIsInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
@@ -11413,7 +11441,7 @@
return true
}
}
-func rewriteValueARM64_OpIsNonNil(v *Value) bool {
+func rewriteValueARM64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
@@ -11429,7 +11457,7 @@
return true
}
}
-func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
@@ -11446,7 +11474,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16(v *Value) bool {
+func rewriteValueARM64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11469,7 +11497,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16U(v *Value) bool {
+func rewriteValueARM64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11492,7 +11520,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32(v *Value) bool {
+func rewriteValueARM64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
@@ -11509,7 +11537,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32F(v *Value) bool {
+func rewriteValueARM64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -11526,7 +11554,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32U(v *Value) bool {
+func rewriteValueARM64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
@@ -11543,7 +11571,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64(v *Value) bool {
+func rewriteValueARM64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
@@ -11560,7 +11588,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64F(v *Value) bool {
+func rewriteValueARM64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -11577,7 +11605,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64U(v *Value) bool {
+func rewriteValueARM64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
@@ -11594,7 +11622,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8(v *Value) bool {
+func rewriteValueARM64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11617,7 +11645,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8U(v *Value) bool {
+func rewriteValueARM64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11640,7 +11668,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16(v *Value) bool {
+func rewriteValueARM64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11663,7 +11691,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16U(v *Value) bool {
+func rewriteValueARM64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11686,7 +11714,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32(v *Value) bool {
+func rewriteValueARM64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
@@ -11703,7 +11731,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32F(v *Value) bool {
+func rewriteValueARM64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -11720,7 +11748,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32U(v *Value) bool {
+func rewriteValueARM64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
@@ -11737,7 +11765,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64(v *Value) bool {
+func rewriteValueARM64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
@@ -11754,7 +11782,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64F(v *Value) bool {
+func rewriteValueARM64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -11771,7 +11799,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64U(v *Value) bool {
+func rewriteValueARM64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
@@ -11788,7 +11816,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8(v *Value) bool {
+func rewriteValueARM64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11811,7 +11839,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8U(v *Value) bool {
+func rewriteValueARM64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -11834,7 +11862,7 @@
return true
}
}
-func rewriteValueARM64_OpLoad(v *Value) bool {
+func rewriteValueARM64_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
@@ -11987,7 +12015,7 @@
}
return false
}
-func rewriteValueARM64_OpLsh16x16(v *Value) bool {
+func rewriteValueARM64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12018,7 +12046,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x32(v *Value) bool {
+func rewriteValueARM64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12049,7 +12077,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x64(v *Value) bool {
+func rewriteValueARM64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 x (MOVDconst [c]))
@@ -12108,7 +12136,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x8(v *Value) bool {
+func rewriteValueARM64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12139,7 +12167,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x16(v *Value) bool {
+func rewriteValueARM64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12170,7 +12198,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x32(v *Value) bool {
+func rewriteValueARM64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12201,7 +12229,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x64(v *Value) bool {
+func rewriteValueARM64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 x (MOVDconst [c]))
@@ -12260,7 +12288,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x8(v *Value) bool {
+func rewriteValueARM64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12291,7 +12319,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x16(v *Value) bool {
+func rewriteValueARM64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12322,7 +12350,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x32(v *Value) bool {
+func rewriteValueARM64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12353,7 +12381,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x64(v *Value) bool {
+func rewriteValueARM64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 x (MOVDconst [c]))
@@ -12412,7 +12440,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x8(v *Value) bool {
+func rewriteValueARM64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12443,7 +12471,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x16(v *Value) bool {
+func rewriteValueARM64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12474,7 +12502,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x32(v *Value) bool {
+func rewriteValueARM64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12505,7 +12533,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x64(v *Value) bool {
+func rewriteValueARM64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 x (MOVDconst [c]))
@@ -12564,7 +12592,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x8(v *Value) bool {
+func rewriteValueARM64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12595,7 +12623,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16(v *Value) bool {
+func rewriteValueARM64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12616,7 +12644,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16u(v *Value) bool {
+func rewriteValueARM64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12637,7 +12665,7 @@
return true
}
}
-func rewriteValueARM64_OpMod32(v *Value) bool {
+func rewriteValueARM64_OpMod32_0(v *Value) bool {
// match: (Mod32 x y)
// cond:
// result: (MODW x y)
@@ -12650,7 +12678,7 @@
return true
}
}
-func rewriteValueARM64_OpMod32u(v *Value) bool {
+func rewriteValueARM64_OpMod32u_0(v *Value) bool {
// match: (Mod32u x y)
// cond:
// result: (UMODW x y)
@@ -12663,7 +12691,7 @@
return true
}
}
-func rewriteValueARM64_OpMod64(v *Value) bool {
+func rewriteValueARM64_OpMod64_0(v *Value) bool {
// match: (Mod64 x y)
// cond:
// result: (MOD x y)
@@ -12676,7 +12704,7 @@
return true
}
}
-func rewriteValueARM64_OpMod64u(v *Value) bool {
+func rewriteValueARM64_OpMod64u_0(v *Value) bool {
// match: (Mod64u x y)
// cond:
// result: (UMOD x y)
@@ -12689,7 +12717,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8(v *Value) bool {
+func rewriteValueARM64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12710,7 +12738,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8u(v *Value) bool {
+func rewriteValueARM64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -12731,11 +12759,9 @@
return true
}
}
-func rewriteValueARM64_OpMove(v *Value) bool {
+func rewriteValueARM64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
@@ -12976,6 +13002,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [16] dst src mem)
// cond:
// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
@@ -13111,7 +13146,7 @@
}
return false
}
-func rewriteValueARM64_OpMul16(v *Value) bool {
+func rewriteValueARM64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULW x y)
@@ -13124,7 +13159,7 @@
return true
}
}
-func rewriteValueARM64_OpMul32(v *Value) bool {
+func rewriteValueARM64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULW x y)
@@ -13137,7 +13172,7 @@
return true
}
}
-func rewriteValueARM64_OpMul32F(v *Value) bool {
+func rewriteValueARM64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
@@ -13150,7 +13185,7 @@
return true
}
}
-func rewriteValueARM64_OpMul64(v *Value) bool {
+func rewriteValueARM64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MUL x y)
@@ -13163,7 +13198,7 @@
return true
}
}
-func rewriteValueARM64_OpMul64F(v *Value) bool {
+func rewriteValueARM64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMULD x y)
@@ -13176,7 +13211,7 @@
return true
}
}
-func rewriteValueARM64_OpMul8(v *Value) bool {
+func rewriteValueARM64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULW x y)
@@ -13189,7 +13224,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg16(v *Value) bool {
+func rewriteValueARM64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
@@ -13200,7 +13235,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg32(v *Value) bool {
+func rewriteValueARM64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
@@ -13211,7 +13246,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg32F(v *Value) bool {
+func rewriteValueARM64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEGS x)
@@ -13222,7 +13257,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg64(v *Value) bool {
+func rewriteValueARM64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
@@ -13233,7 +13268,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg64F(v *Value) bool {
+func rewriteValueARM64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEGD x)
@@ -13244,7 +13279,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg8(v *Value) bool {
+func rewriteValueARM64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
@@ -13255,7 +13290,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq16(v *Value) bool {
+func rewriteValueARM64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13278,7 +13313,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32(v *Value) bool {
+func rewriteValueARM64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
@@ -13295,7 +13330,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32F(v *Value) bool {
+func rewriteValueARM64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -13312,7 +13347,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64(v *Value) bool {
+func rewriteValueARM64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
@@ -13329,7 +13364,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64F(v *Value) bool {
+func rewriteValueARM64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -13346,7 +13381,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq8(v *Value) bool {
+func rewriteValueARM64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13369,7 +13404,7 @@
return true
}
}
-func rewriteValueARM64_OpNeqB(v *Value) bool {
+func rewriteValueARM64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
@@ -13382,7 +13417,7 @@
return true
}
}
-func rewriteValueARM64_OpNeqPtr(v *Value) bool {
+func rewriteValueARM64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
@@ -13399,7 +13434,7 @@
return true
}
}
-func rewriteValueARM64_OpNilCheck(v *Value) bool {
+func rewriteValueARM64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -13412,7 +13447,7 @@
return true
}
}
-func rewriteValueARM64_OpNot(v *Value) bool {
+func rewriteValueARM64_OpNot_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13430,7 +13465,7 @@
return true
}
}
-func rewriteValueARM64_OpOffPtr(v *Value) bool {
+func rewriteValueARM64_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVDaddr [off] ptr)
@@ -13457,7 +13492,7 @@
return true
}
}
-func rewriteValueARM64_OpOr16(v *Value) bool {
+func rewriteValueARM64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
@@ -13470,7 +13505,7 @@
return true
}
}
-func rewriteValueARM64_OpOr32(v *Value) bool {
+func rewriteValueARM64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
@@ -13483,7 +13518,7 @@
return true
}
}
-func rewriteValueARM64_OpOr64(v *Value) bool {
+func rewriteValueARM64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
@@ -13496,7 +13531,7 @@
return true
}
}
-func rewriteValueARM64_OpOr8(v *Value) bool {
+func rewriteValueARM64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
@@ -13509,7 +13544,7 @@
return true
}
}
-func rewriteValueARM64_OpOrB(v *Value) bool {
+func rewriteValueARM64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
@@ -13522,7 +13557,7 @@
return true
}
}
-func rewriteValueARM64_OpRound32F(v *Value) bool {
+func rewriteValueARM64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
@@ -13534,7 +13569,7 @@
return true
}
}
-func rewriteValueARM64_OpRound64F(v *Value) bool {
+func rewriteValueARM64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
@@ -13546,7 +13581,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13579,7 +13614,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13612,7 +13647,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13677,7 +13712,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13710,7 +13745,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x16(v *Value) bool {
+func rewriteValueARM64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13742,7 +13777,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x32(v *Value) bool {
+func rewriteValueARM64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13774,7 +13809,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x64(v *Value) bool {
+func rewriteValueARM64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13842,7 +13877,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x8(v *Value) bool {
+func rewriteValueARM64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13874,7 +13909,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13907,7 +13942,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -13940,7 +13975,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14005,7 +14040,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14038,7 +14073,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x16(v *Value) bool {
+func rewriteValueARM64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14070,7 +14105,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x32(v *Value) bool {
+func rewriteValueARM64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14102,7 +14137,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x64(v *Value) bool {
+func rewriteValueARM64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14170,7 +14205,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x8(v *Value) bool {
+func rewriteValueARM64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14202,7 +14237,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14233,7 +14268,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14264,7 +14299,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 x (MOVDconst [c]))
@@ -14323,7 +14358,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14354,7 +14389,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x16(v *Value) bool {
+func rewriteValueARM64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14384,7 +14419,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x32(v *Value) bool {
+func rewriteValueARM64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14414,7 +14449,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x64(v *Value) bool {
+func rewriteValueARM64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 x (MOVDconst [c]))
@@ -14474,7 +14509,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x8(v *Value) bool {
+func rewriteValueARM64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14504,7 +14539,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14537,7 +14572,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14570,7 +14605,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14635,7 +14670,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14668,7 +14703,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x16(v *Value) bool {
+func rewriteValueARM64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14700,7 +14735,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x32(v *Value) bool {
+func rewriteValueARM64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14732,7 +14767,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x64(v *Value) bool {
+func rewriteValueARM64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14800,7 +14835,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x8(v *Value) bool {
+func rewriteValueARM64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -14832,7 +14867,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
@@ -14843,7 +14878,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt16to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
@@ -14854,7 +14889,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt32to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
@@ -14865,7 +14900,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
@@ -14876,7 +14911,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
@@ -14887,7 +14922,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
@@ -14898,7 +14933,7 @@
return true
}
}
-func rewriteValueARM64_OpSlicemask(v *Value) bool {
+func rewriteValueARM64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -14915,7 +14950,7 @@
return true
}
}
-func rewriteValueARM64_OpSqrt(v *Value) bool {
+func rewriteValueARM64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRTD x)
@@ -14926,7 +14961,7 @@
return true
}
}
-func rewriteValueARM64_OpStaticCall(v *Value) bool {
+func rewriteValueARM64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -14941,7 +14976,7 @@
return true
}
}
-func rewriteValueARM64_OpStore(v *Value) bool {
+func rewriteValueARM64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
@@ -15046,7 +15081,7 @@
}
return false
}
-func rewriteValueARM64_OpSub16(v *Value) bool {
+func rewriteValueARM64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
@@ -15059,7 +15094,7 @@
return true
}
}
-func rewriteValueARM64_OpSub32(v *Value) bool {
+func rewriteValueARM64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
@@ -15072,7 +15107,7 @@
return true
}
}
-func rewriteValueARM64_OpSub32F(v *Value) bool {
+func rewriteValueARM64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
@@ -15085,7 +15120,7 @@
return true
}
}
-func rewriteValueARM64_OpSub64(v *Value) bool {
+func rewriteValueARM64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
@@ -15098,7 +15133,7 @@
return true
}
}
-func rewriteValueARM64_OpSub64F(v *Value) bool {
+func rewriteValueARM64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUBD x y)
@@ -15111,7 +15146,7 @@
return true
}
}
-func rewriteValueARM64_OpSub8(v *Value) bool {
+func rewriteValueARM64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
@@ -15124,7 +15159,7 @@
return true
}
}
-func rewriteValueARM64_OpSubPtr(v *Value) bool {
+func rewriteValueARM64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
@@ -15137,7 +15172,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -15149,7 +15184,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -15161,7 +15196,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -15173,7 +15208,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
@@ -15185,7 +15220,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to32(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
@@ -15197,7 +15232,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
@@ -15209,7 +15244,7 @@
return true
}
}
-func rewriteValueARM64_OpXor16(v *Value) bool {
+func rewriteValueARM64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
@@ -15222,7 +15257,7 @@
return true
}
}
-func rewriteValueARM64_OpXor32(v *Value) bool {
+func rewriteValueARM64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
@@ -15235,7 +15270,7 @@
return true
}
}
-func rewriteValueARM64_OpXor64(v *Value) bool {
+func rewriteValueARM64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
@@ -15248,7 +15283,7 @@
return true
}
}
-func rewriteValueARM64_OpXor8(v *Value) bool {
+func rewriteValueARM64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
@@ -15261,11 +15296,9 @@
return true
}
}
-func rewriteValueARM64_OpZero(v *Value) bool {
+func rewriteValueARM64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
@@ -15476,6 +15509,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [16] ptr mem)
// cond:
// result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
@@ -15591,7 +15633,7 @@
}
return false
}
-func rewriteValueARM64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
@@ -15602,7 +15644,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHUreg x)
@@ -15613,7 +15655,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWUreg x)
@@ -15624,7 +15666,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
@@ -15635,7 +15677,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
@@ -15646,7 +15688,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 64a6ddf..bed923b 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -14,499 +14,499 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
return true
}
}
-func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -1718,7 +1718,7 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
return true
}
}
-func rewriteValueMIPS_OpZeromask(v *Value) bool {
+func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 3c23d2d..7958537 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -14,563 +14,563 @@
func rewriteValueMIPS64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS64_OpAdd16(v)
+ return rewriteValueMIPS64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueMIPS64_OpAdd32(v)
+ return rewriteValueMIPS64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueMIPS64_OpAdd32F(v)
+ return rewriteValueMIPS64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueMIPS64_OpAdd64(v)
+ return rewriteValueMIPS64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueMIPS64_OpAdd64F(v)
+ return rewriteValueMIPS64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueMIPS64_OpAdd8(v)
+ return rewriteValueMIPS64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueMIPS64_OpAddPtr(v)
+ return rewriteValueMIPS64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueMIPS64_OpAddr(v)
+ return rewriteValueMIPS64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueMIPS64_OpAnd16(v)
+ return rewriteValueMIPS64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueMIPS64_OpAnd32(v)
+ return rewriteValueMIPS64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueMIPS64_OpAnd64(v)
+ return rewriteValueMIPS64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueMIPS64_OpAnd8(v)
+ return rewriteValueMIPS64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueMIPS64_OpAndB(v)
+ return rewriteValueMIPS64_OpAndB_0(v)
case OpAvg64u:
- return rewriteValueMIPS64_OpAvg64u(v)
+ return rewriteValueMIPS64_OpAvg64u_0(v)
case OpClosureCall:
- return rewriteValueMIPS64_OpClosureCall(v)
+ return rewriteValueMIPS64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueMIPS64_OpCom16(v)
+ return rewriteValueMIPS64_OpCom16_0(v)
case OpCom32:
- return rewriteValueMIPS64_OpCom32(v)
+ return rewriteValueMIPS64_OpCom32_0(v)
case OpCom64:
- return rewriteValueMIPS64_OpCom64(v)
+ return rewriteValueMIPS64_OpCom64_0(v)
case OpCom8:
- return rewriteValueMIPS64_OpCom8(v)
+ return rewriteValueMIPS64_OpCom8_0(v)
case OpConst16:
- return rewriteValueMIPS64_OpConst16(v)
+ return rewriteValueMIPS64_OpConst16_0(v)
case OpConst32:
- return rewriteValueMIPS64_OpConst32(v)
+ return rewriteValueMIPS64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueMIPS64_OpConst32F(v)
+ return rewriteValueMIPS64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueMIPS64_OpConst64(v)
+ return rewriteValueMIPS64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueMIPS64_OpConst64F(v)
+ return rewriteValueMIPS64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueMIPS64_OpConst8(v)
+ return rewriteValueMIPS64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueMIPS64_OpConstBool(v)
+ return rewriteValueMIPS64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueMIPS64_OpConstNil(v)
+ return rewriteValueMIPS64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueMIPS64_OpConvert(v)
+ return rewriteValueMIPS64_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValueMIPS64_OpCvt32Fto32(v)
+ return rewriteValueMIPS64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueMIPS64_OpCvt32Fto64(v)
+ return rewriteValueMIPS64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueMIPS64_OpCvt32Fto64F(v)
+ return rewriteValueMIPS64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueMIPS64_OpCvt32to32F(v)
+ return rewriteValueMIPS64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueMIPS64_OpCvt32to64F(v)
+ return rewriteValueMIPS64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueMIPS64_OpCvt64Fto32(v)
+ return rewriteValueMIPS64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueMIPS64_OpCvt64Fto32F(v)
+ return rewriteValueMIPS64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueMIPS64_OpCvt64Fto64(v)
+ return rewriteValueMIPS64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueMIPS64_OpCvt64to32F(v)
+ return rewriteValueMIPS64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueMIPS64_OpCvt64to64F(v)
+ return rewriteValueMIPS64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueMIPS64_OpDiv16(v)
+ return rewriteValueMIPS64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueMIPS64_OpDiv16u(v)
+ return rewriteValueMIPS64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueMIPS64_OpDiv32(v)
+ return rewriteValueMIPS64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueMIPS64_OpDiv32F(v)
+ return rewriteValueMIPS64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueMIPS64_OpDiv32u(v)
+ return rewriteValueMIPS64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueMIPS64_OpDiv64(v)
+ return rewriteValueMIPS64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueMIPS64_OpDiv64F(v)
+ return rewriteValueMIPS64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueMIPS64_OpDiv64u(v)
+ return rewriteValueMIPS64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueMIPS64_OpDiv8(v)
+ return rewriteValueMIPS64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueMIPS64_OpDiv8u(v)
+ return rewriteValueMIPS64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueMIPS64_OpEq16(v)
+ return rewriteValueMIPS64_OpEq16_0(v)
case OpEq32:
- return rewriteValueMIPS64_OpEq32(v)
+ return rewriteValueMIPS64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueMIPS64_OpEq32F(v)
+ return rewriteValueMIPS64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueMIPS64_OpEq64(v)
+ return rewriteValueMIPS64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueMIPS64_OpEq64F(v)
+ return rewriteValueMIPS64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueMIPS64_OpEq8(v)
+ return rewriteValueMIPS64_OpEq8_0(v)
case OpEqB:
- return rewriteValueMIPS64_OpEqB(v)
+ return rewriteValueMIPS64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueMIPS64_OpEqPtr(v)
+ return rewriteValueMIPS64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueMIPS64_OpGeq16(v)
+ return rewriteValueMIPS64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueMIPS64_OpGeq16U(v)
+ return rewriteValueMIPS64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueMIPS64_OpGeq32(v)
+ return rewriteValueMIPS64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueMIPS64_OpGeq32F(v)
+ return rewriteValueMIPS64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueMIPS64_OpGeq32U(v)
+ return rewriteValueMIPS64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueMIPS64_OpGeq64(v)
+ return rewriteValueMIPS64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueMIPS64_OpGeq64F(v)
+ return rewriteValueMIPS64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueMIPS64_OpGeq64U(v)
+ return rewriteValueMIPS64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueMIPS64_OpGeq8(v)
+ return rewriteValueMIPS64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueMIPS64_OpGeq8U(v)
+ return rewriteValueMIPS64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueMIPS64_OpGetClosurePtr(v)
+ return rewriteValueMIPS64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueMIPS64_OpGreater16(v)
+ return rewriteValueMIPS64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueMIPS64_OpGreater16U(v)
+ return rewriteValueMIPS64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueMIPS64_OpGreater32(v)
+ return rewriteValueMIPS64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueMIPS64_OpGreater32F(v)
+ return rewriteValueMIPS64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueMIPS64_OpGreater32U(v)
+ return rewriteValueMIPS64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueMIPS64_OpGreater64(v)
+ return rewriteValueMIPS64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueMIPS64_OpGreater64F(v)
+ return rewriteValueMIPS64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueMIPS64_OpGreater64U(v)
+ return rewriteValueMIPS64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueMIPS64_OpGreater8(v)
+ return rewriteValueMIPS64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueMIPS64_OpGreater8U(v)
+ return rewriteValueMIPS64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueMIPS64_OpHmul32(v)
+ return rewriteValueMIPS64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueMIPS64_OpHmul32u(v)
+ return rewriteValueMIPS64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueMIPS64_OpHmul64(v)
+ return rewriteValueMIPS64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueMIPS64_OpHmul64u(v)
+ return rewriteValueMIPS64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValueMIPS64_OpInterCall(v)
+ return rewriteValueMIPS64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueMIPS64_OpIsInBounds(v)
+ return rewriteValueMIPS64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueMIPS64_OpIsNonNil(v)
+ return rewriteValueMIPS64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueMIPS64_OpIsSliceInBounds(v)
+ return rewriteValueMIPS64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueMIPS64_OpLeq16(v)
+ return rewriteValueMIPS64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueMIPS64_OpLeq16U(v)
+ return rewriteValueMIPS64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueMIPS64_OpLeq32(v)
+ return rewriteValueMIPS64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueMIPS64_OpLeq32F(v)
+ return rewriteValueMIPS64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueMIPS64_OpLeq32U(v)
+ return rewriteValueMIPS64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueMIPS64_OpLeq64(v)
+ return rewriteValueMIPS64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueMIPS64_OpLeq64F(v)
+ return rewriteValueMIPS64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueMIPS64_OpLeq64U(v)
+ return rewriteValueMIPS64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueMIPS64_OpLeq8(v)
+ return rewriteValueMIPS64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueMIPS64_OpLeq8U(v)
+ return rewriteValueMIPS64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueMIPS64_OpLess16(v)
+ return rewriteValueMIPS64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueMIPS64_OpLess16U(v)
+ return rewriteValueMIPS64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueMIPS64_OpLess32(v)
+ return rewriteValueMIPS64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueMIPS64_OpLess32F(v)
+ return rewriteValueMIPS64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueMIPS64_OpLess32U(v)
+ return rewriteValueMIPS64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueMIPS64_OpLess64(v)
+ return rewriteValueMIPS64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueMIPS64_OpLess64F(v)
+ return rewriteValueMIPS64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueMIPS64_OpLess64U(v)
+ return rewriteValueMIPS64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueMIPS64_OpLess8(v)
+ return rewriteValueMIPS64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueMIPS64_OpLess8U(v)
+ return rewriteValueMIPS64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueMIPS64_OpLoad(v)
+ return rewriteValueMIPS64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueMIPS64_OpLsh16x16(v)
+ return rewriteValueMIPS64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueMIPS64_OpLsh16x32(v)
+ return rewriteValueMIPS64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueMIPS64_OpLsh16x64(v)
+ return rewriteValueMIPS64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueMIPS64_OpLsh16x8(v)
+ return rewriteValueMIPS64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueMIPS64_OpLsh32x16(v)
+ return rewriteValueMIPS64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueMIPS64_OpLsh32x32(v)
+ return rewriteValueMIPS64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueMIPS64_OpLsh32x64(v)
+ return rewriteValueMIPS64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueMIPS64_OpLsh32x8(v)
+ return rewriteValueMIPS64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueMIPS64_OpLsh64x16(v)
+ return rewriteValueMIPS64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueMIPS64_OpLsh64x32(v)
+ return rewriteValueMIPS64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueMIPS64_OpLsh64x64(v)
+ return rewriteValueMIPS64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueMIPS64_OpLsh64x8(v)
+ return rewriteValueMIPS64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueMIPS64_OpLsh8x16(v)
+ return rewriteValueMIPS64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueMIPS64_OpLsh8x32(v)
+ return rewriteValueMIPS64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueMIPS64_OpLsh8x64(v)
+ return rewriteValueMIPS64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueMIPS64_OpLsh8x8(v)
+ return rewriteValueMIPS64_OpLsh8x8_0(v)
case OpMIPS64ADDV:
- return rewriteValueMIPS64_OpMIPS64ADDV(v)
+ return rewriteValueMIPS64_OpMIPS64ADDV_0(v)
case OpMIPS64ADDVconst:
- return rewriteValueMIPS64_OpMIPS64ADDVconst(v)
+ return rewriteValueMIPS64_OpMIPS64ADDVconst_0(v)
case OpMIPS64AND:
- return rewriteValueMIPS64_OpMIPS64AND(v)
+ return rewriteValueMIPS64_OpMIPS64AND_0(v)
case OpMIPS64ANDconst:
- return rewriteValueMIPS64_OpMIPS64ANDconst(v)
+ return rewriteValueMIPS64_OpMIPS64ANDconst_0(v)
case OpMIPS64MOVBUload:
- return rewriteValueMIPS64_OpMIPS64MOVBUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUload_0(v)
case OpMIPS64MOVBUreg:
- return rewriteValueMIPS64_OpMIPS64MOVBUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v)
case OpMIPS64MOVBload:
- return rewriteValueMIPS64_OpMIPS64MOVBload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBload_0(v)
case OpMIPS64MOVBreg:
- return rewriteValueMIPS64_OpMIPS64MOVBreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBreg_0(v)
case OpMIPS64MOVBstore:
- return rewriteValueMIPS64_OpMIPS64MOVBstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstore_0(v)
case OpMIPS64MOVBstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v)
case OpMIPS64MOVDload:
- return rewriteValueMIPS64_OpMIPS64MOVDload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDload_0(v)
case OpMIPS64MOVDstore:
- return rewriteValueMIPS64_OpMIPS64MOVDstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDstore_0(v)
case OpMIPS64MOVFload:
- return rewriteValueMIPS64_OpMIPS64MOVFload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFload_0(v)
case OpMIPS64MOVFstore:
- return rewriteValueMIPS64_OpMIPS64MOVFstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFstore_0(v)
case OpMIPS64MOVHUload:
- return rewriteValueMIPS64_OpMIPS64MOVHUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUload_0(v)
case OpMIPS64MOVHUreg:
- return rewriteValueMIPS64_OpMIPS64MOVHUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v)
case OpMIPS64MOVHload:
- return rewriteValueMIPS64_OpMIPS64MOVHload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHload_0(v)
case OpMIPS64MOVHreg:
- return rewriteValueMIPS64_OpMIPS64MOVHreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHreg_0(v)
case OpMIPS64MOVHstore:
- return rewriteValueMIPS64_OpMIPS64MOVHstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstore_0(v)
case OpMIPS64MOVHstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v)
case OpMIPS64MOVVload:
- return rewriteValueMIPS64_OpMIPS64MOVVload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVload_0(v)
case OpMIPS64MOVVreg:
- return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVreg_0(v)
case OpMIPS64MOVVstore:
- return rewriteValueMIPS64_OpMIPS64MOVVstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstore_0(v)
case OpMIPS64MOVVstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v)
case OpMIPS64MOVWUload:
- return rewriteValueMIPS64_OpMIPS64MOVWUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUload_0(v)
case OpMIPS64MOVWUreg:
- return rewriteValueMIPS64_OpMIPS64MOVWUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v)
case OpMIPS64MOVWload:
- return rewriteValueMIPS64_OpMIPS64MOVWload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWload_0(v)
case OpMIPS64MOVWreg:
- return rewriteValueMIPS64_OpMIPS64MOVWreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWreg_0(v) || rewriteValueMIPS64_OpMIPS64MOVWreg_10(v)
case OpMIPS64MOVWstore:
- return rewriteValueMIPS64_OpMIPS64MOVWstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstore_0(v)
case OpMIPS64MOVWstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v)
case OpMIPS64NEGV:
- return rewriteValueMIPS64_OpMIPS64NEGV(v)
+ return rewriteValueMIPS64_OpMIPS64NEGV_0(v)
case OpMIPS64NOR:
- return rewriteValueMIPS64_OpMIPS64NOR(v)
+ return rewriteValueMIPS64_OpMIPS64NOR_0(v)
case OpMIPS64NORconst:
- return rewriteValueMIPS64_OpMIPS64NORconst(v)
+ return rewriteValueMIPS64_OpMIPS64NORconst_0(v)
case OpMIPS64OR:
- return rewriteValueMIPS64_OpMIPS64OR(v)
+ return rewriteValueMIPS64_OpMIPS64OR_0(v)
case OpMIPS64ORconst:
- return rewriteValueMIPS64_OpMIPS64ORconst(v)
+ return rewriteValueMIPS64_OpMIPS64ORconst_0(v)
case OpMIPS64SGT:
- return rewriteValueMIPS64_OpMIPS64SGT(v)
+ return rewriteValueMIPS64_OpMIPS64SGT_0(v)
case OpMIPS64SGTU:
- return rewriteValueMIPS64_OpMIPS64SGTU(v)
+ return rewriteValueMIPS64_OpMIPS64SGTU_0(v)
case OpMIPS64SGTUconst:
- return rewriteValueMIPS64_OpMIPS64SGTUconst(v)
+ return rewriteValueMIPS64_OpMIPS64SGTUconst_0(v)
case OpMIPS64SGTconst:
- return rewriteValueMIPS64_OpMIPS64SGTconst(v)
+ return rewriteValueMIPS64_OpMIPS64SGTconst_0(v) || rewriteValueMIPS64_OpMIPS64SGTconst_10(v)
case OpMIPS64SLLV:
- return rewriteValueMIPS64_OpMIPS64SLLV(v)
+ return rewriteValueMIPS64_OpMIPS64SLLV_0(v)
case OpMIPS64SLLVconst:
- return rewriteValueMIPS64_OpMIPS64SLLVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SLLVconst_0(v)
case OpMIPS64SRAV:
- return rewriteValueMIPS64_OpMIPS64SRAV(v)
+ return rewriteValueMIPS64_OpMIPS64SRAV_0(v)
case OpMIPS64SRAVconst:
- return rewriteValueMIPS64_OpMIPS64SRAVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SRAVconst_0(v)
case OpMIPS64SRLV:
- return rewriteValueMIPS64_OpMIPS64SRLV(v)
+ return rewriteValueMIPS64_OpMIPS64SRLV_0(v)
case OpMIPS64SRLVconst:
- return rewriteValueMIPS64_OpMIPS64SRLVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SRLVconst_0(v)
case OpMIPS64SUBV:
- return rewriteValueMIPS64_OpMIPS64SUBV(v)
+ return rewriteValueMIPS64_OpMIPS64SUBV_0(v)
case OpMIPS64SUBVconst:
- return rewriteValueMIPS64_OpMIPS64SUBVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SUBVconst_0(v)
case OpMIPS64XOR:
- return rewriteValueMIPS64_OpMIPS64XOR(v)
+ return rewriteValueMIPS64_OpMIPS64XOR_0(v)
case OpMIPS64XORconst:
- return rewriteValueMIPS64_OpMIPS64XORconst(v)
+ return rewriteValueMIPS64_OpMIPS64XORconst_0(v)
case OpMod16:
- return rewriteValueMIPS64_OpMod16(v)
+ return rewriteValueMIPS64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueMIPS64_OpMod16u(v)
+ return rewriteValueMIPS64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueMIPS64_OpMod32(v)
+ return rewriteValueMIPS64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueMIPS64_OpMod32u(v)
+ return rewriteValueMIPS64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueMIPS64_OpMod64(v)
+ return rewriteValueMIPS64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueMIPS64_OpMod64u(v)
+ return rewriteValueMIPS64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueMIPS64_OpMod8(v)
+ return rewriteValueMIPS64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueMIPS64_OpMod8u(v)
+ return rewriteValueMIPS64_OpMod8u_0(v)
case OpMove:
- return rewriteValueMIPS64_OpMove(v)
+ return rewriteValueMIPS64_OpMove_0(v) || rewriteValueMIPS64_OpMove_10(v)
case OpMul16:
- return rewriteValueMIPS64_OpMul16(v)
+ return rewriteValueMIPS64_OpMul16_0(v)
case OpMul32:
- return rewriteValueMIPS64_OpMul32(v)
+ return rewriteValueMIPS64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueMIPS64_OpMul32F(v)
+ return rewriteValueMIPS64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueMIPS64_OpMul64(v)
+ return rewriteValueMIPS64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueMIPS64_OpMul64F(v)
+ return rewriteValueMIPS64_OpMul64F_0(v)
case OpMul8:
- return rewriteValueMIPS64_OpMul8(v)
+ return rewriteValueMIPS64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueMIPS64_OpNeg16(v)
+ return rewriteValueMIPS64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueMIPS64_OpNeg32(v)
+ return rewriteValueMIPS64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueMIPS64_OpNeg32F(v)
+ return rewriteValueMIPS64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueMIPS64_OpNeg64(v)
+ return rewriteValueMIPS64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueMIPS64_OpNeg64F(v)
+ return rewriteValueMIPS64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueMIPS64_OpNeg8(v)
+ return rewriteValueMIPS64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueMIPS64_OpNeq16(v)
+ return rewriteValueMIPS64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueMIPS64_OpNeq32(v)
+ return rewriteValueMIPS64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueMIPS64_OpNeq32F(v)
+ return rewriteValueMIPS64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueMIPS64_OpNeq64(v)
+ return rewriteValueMIPS64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueMIPS64_OpNeq64F(v)
+ return rewriteValueMIPS64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueMIPS64_OpNeq8(v)
+ return rewriteValueMIPS64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueMIPS64_OpNeqB(v)
+ return rewriteValueMIPS64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueMIPS64_OpNeqPtr(v)
+ return rewriteValueMIPS64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueMIPS64_OpNilCheck(v)
+ return rewriteValueMIPS64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueMIPS64_OpNot(v)
+ return rewriteValueMIPS64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueMIPS64_OpOffPtr(v)
+ return rewriteValueMIPS64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueMIPS64_OpOr16(v)
+ return rewriteValueMIPS64_OpOr16_0(v)
case OpOr32:
- return rewriteValueMIPS64_OpOr32(v)
+ return rewriteValueMIPS64_OpOr32_0(v)
case OpOr64:
- return rewriteValueMIPS64_OpOr64(v)
+ return rewriteValueMIPS64_OpOr64_0(v)
case OpOr8:
- return rewriteValueMIPS64_OpOr8(v)
+ return rewriteValueMIPS64_OpOr8_0(v)
case OpOrB:
- return rewriteValueMIPS64_OpOrB(v)
+ return rewriteValueMIPS64_OpOrB_0(v)
case OpRound32F:
- return rewriteValueMIPS64_OpRound32F(v)
+ return rewriteValueMIPS64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueMIPS64_OpRound64F(v)
+ return rewriteValueMIPS64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueMIPS64_OpRsh16Ux16(v)
+ return rewriteValueMIPS64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueMIPS64_OpRsh16Ux32(v)
+ return rewriteValueMIPS64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueMIPS64_OpRsh16Ux64(v)
+ return rewriteValueMIPS64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueMIPS64_OpRsh16Ux8(v)
+ return rewriteValueMIPS64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueMIPS64_OpRsh16x16(v)
+ return rewriteValueMIPS64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueMIPS64_OpRsh16x32(v)
+ return rewriteValueMIPS64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueMIPS64_OpRsh16x64(v)
+ return rewriteValueMIPS64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueMIPS64_OpRsh16x8(v)
+ return rewriteValueMIPS64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueMIPS64_OpRsh32Ux16(v)
+ return rewriteValueMIPS64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueMIPS64_OpRsh32Ux32(v)
+ return rewriteValueMIPS64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueMIPS64_OpRsh32Ux64(v)
+ return rewriteValueMIPS64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueMIPS64_OpRsh32Ux8(v)
+ return rewriteValueMIPS64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueMIPS64_OpRsh32x16(v)
+ return rewriteValueMIPS64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueMIPS64_OpRsh32x32(v)
+ return rewriteValueMIPS64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueMIPS64_OpRsh32x64(v)
+ return rewriteValueMIPS64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueMIPS64_OpRsh32x8(v)
+ return rewriteValueMIPS64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueMIPS64_OpRsh64Ux16(v)
+ return rewriteValueMIPS64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueMIPS64_OpRsh64Ux32(v)
+ return rewriteValueMIPS64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueMIPS64_OpRsh64Ux64(v)
+ return rewriteValueMIPS64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueMIPS64_OpRsh64Ux8(v)
+ return rewriteValueMIPS64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueMIPS64_OpRsh64x16(v)
+ return rewriteValueMIPS64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueMIPS64_OpRsh64x32(v)
+ return rewriteValueMIPS64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueMIPS64_OpRsh64x64(v)
+ return rewriteValueMIPS64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueMIPS64_OpRsh64x8(v)
+ return rewriteValueMIPS64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueMIPS64_OpRsh8Ux16(v)
+ return rewriteValueMIPS64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueMIPS64_OpRsh8Ux32(v)
+ return rewriteValueMIPS64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueMIPS64_OpRsh8Ux64(v)
+ return rewriteValueMIPS64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueMIPS64_OpRsh8Ux8(v)
+ return rewriteValueMIPS64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueMIPS64_OpRsh8x16(v)
+ return rewriteValueMIPS64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueMIPS64_OpRsh8x32(v)
+ return rewriteValueMIPS64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueMIPS64_OpRsh8x64(v)
+ return rewriteValueMIPS64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueMIPS64_OpRsh8x8(v)
+ return rewriteValueMIPS64_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueMIPS64_OpSelect0(v)
+ return rewriteValueMIPS64_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueMIPS64_OpSelect1(v)
+ return rewriteValueMIPS64_OpSelect1_0(v) || rewriteValueMIPS64_OpSelect1_10(v) || rewriteValueMIPS64_OpSelect1_20(v)
case OpSignExt16to32:
- return rewriteValueMIPS64_OpSignExt16to32(v)
+ return rewriteValueMIPS64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueMIPS64_OpSignExt16to64(v)
+ return rewriteValueMIPS64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueMIPS64_OpSignExt32to64(v)
+ return rewriteValueMIPS64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueMIPS64_OpSignExt8to16(v)
+ return rewriteValueMIPS64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueMIPS64_OpSignExt8to32(v)
+ return rewriteValueMIPS64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueMIPS64_OpSignExt8to64(v)
+ return rewriteValueMIPS64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueMIPS64_OpSlicemask(v)
+ return rewriteValueMIPS64_OpSlicemask_0(v)
case OpStaticCall:
- return rewriteValueMIPS64_OpStaticCall(v)
+ return rewriteValueMIPS64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueMIPS64_OpStore(v)
+ return rewriteValueMIPS64_OpStore_0(v)
case OpSub16:
- return rewriteValueMIPS64_OpSub16(v)
+ return rewriteValueMIPS64_OpSub16_0(v)
case OpSub32:
- return rewriteValueMIPS64_OpSub32(v)
+ return rewriteValueMIPS64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueMIPS64_OpSub32F(v)
+ return rewriteValueMIPS64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueMIPS64_OpSub64(v)
+ return rewriteValueMIPS64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueMIPS64_OpSub64F(v)
+ return rewriteValueMIPS64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueMIPS64_OpSub8(v)
+ return rewriteValueMIPS64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueMIPS64_OpSubPtr(v)
+ return rewriteValueMIPS64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueMIPS64_OpTrunc16to8(v)
+ return rewriteValueMIPS64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueMIPS64_OpTrunc32to16(v)
+ return rewriteValueMIPS64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueMIPS64_OpTrunc32to8(v)
+ return rewriteValueMIPS64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueMIPS64_OpTrunc64to16(v)
+ return rewriteValueMIPS64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueMIPS64_OpTrunc64to32(v)
+ return rewriteValueMIPS64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueMIPS64_OpTrunc64to8(v)
+ return rewriteValueMIPS64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueMIPS64_OpXor16(v)
+ return rewriteValueMIPS64_OpXor16_0(v)
case OpXor32:
- return rewriteValueMIPS64_OpXor32(v)
+ return rewriteValueMIPS64_OpXor32_0(v)
case OpXor64:
- return rewriteValueMIPS64_OpXor64(v)
+ return rewriteValueMIPS64_OpXor64_0(v)
case OpXor8:
- return rewriteValueMIPS64_OpXor8(v)
+ return rewriteValueMIPS64_OpXor8_0(v)
case OpZero:
- return rewriteValueMIPS64_OpZero(v)
+ return rewriteValueMIPS64_OpZero_0(v) || rewriteValueMIPS64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueMIPS64_OpZeroExt16to32(v)
+ return rewriteValueMIPS64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueMIPS64_OpZeroExt16to64(v)
+ return rewriteValueMIPS64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueMIPS64_OpZeroExt32to64(v)
+ return rewriteValueMIPS64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueMIPS64_OpZeroExt8to16(v)
+ return rewriteValueMIPS64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueMIPS64_OpZeroExt8to32(v)
+ return rewriteValueMIPS64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueMIPS64_OpZeroExt8to64(v)
+ return rewriteValueMIPS64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueMIPS64_OpAdd16(v *Value) bool {
+func rewriteValueMIPS64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDV x y)
@@ -583,7 +583,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd32(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDV x y)
@@ -596,7 +596,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd32F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
@@ -609,7 +609,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd64(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADDV x y)
@@ -622,7 +622,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd64F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
@@ -635,7 +635,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd8(v *Value) bool {
+func rewriteValueMIPS64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDV x y)
@@ -648,7 +648,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAddPtr(v *Value) bool {
+func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADDV x y)
@@ -661,7 +661,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAddr(v *Value) bool {
+func rewriteValueMIPS64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVVaddr {sym} base)
@@ -674,7 +674,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd16(v *Value) bool {
+func rewriteValueMIPS64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
@@ -687,7 +687,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd32(v *Value) bool {
+func rewriteValueMIPS64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
@@ -700,7 +700,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd64(v *Value) bool {
+func rewriteValueMIPS64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
@@ -713,7 +713,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd8(v *Value) bool {
+func rewriteValueMIPS64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
@@ -726,7 +726,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAndB(v *Value) bool {
+func rewriteValueMIPS64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
@@ -739,7 +739,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAvg64u(v *Value) bool {
+func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
@@ -761,7 +761,7 @@
return true
}
}
-func rewriteValueMIPS64_OpClosureCall(v *Value) bool {
+func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -778,7 +778,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom16(v *Value) bool {
+func rewriteValueMIPS64_OpCom16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -796,7 +796,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom32(v *Value) bool {
+func rewriteValueMIPS64_OpCom32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -814,7 +814,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom64(v *Value) bool {
+func rewriteValueMIPS64_OpCom64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -832,7 +832,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom8(v *Value) bool {
+func rewriteValueMIPS64_OpCom8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -850,7 +850,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst16(v *Value) bool {
+func rewriteValueMIPS64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVVconst [val])
@@ -861,7 +861,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32(v *Value) bool {
+func rewriteValueMIPS64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVVconst [val])
@@ -872,7 +872,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32F(v *Value) bool {
+func rewriteValueMIPS64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
@@ -883,7 +883,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64(v *Value) bool {
+func rewriteValueMIPS64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVVconst [val])
@@ -894,7 +894,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64F(v *Value) bool {
+func rewriteValueMIPS64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
@@ -905,7 +905,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst8(v *Value) bool {
+func rewriteValueMIPS64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVVconst [val])
@@ -916,7 +916,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstBool(v *Value) bool {
+func rewriteValueMIPS64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVVconst [b])
@@ -927,7 +927,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstNil(v *Value) bool {
+func rewriteValueMIPS64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVVconst [0])
@@ -937,7 +937,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConvert(v *Value) bool {
+func rewriteValueMIPS64_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVVconvert x mem)
@@ -950,7 +950,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (TRUNCFW x)
@@ -961,7 +961,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (TRUNCFV x)
@@ -972,7 +972,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
@@ -983,7 +983,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
@@ -994,7 +994,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
@@ -1005,7 +1005,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (TRUNCDW x)
@@ -1016,7 +1016,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
@@ -1027,7 +1027,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (TRUNCDV x)
@@ -1038,7 +1038,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (MOVVF x)
@@ -1049,7 +1049,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (MOVVD x)
@@ -1060,7 +1060,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1083,7 +1083,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1106,7 +1106,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1129,7 +1129,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
@@ -1142,7 +1142,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1165,7 +1165,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1184,7 +1184,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
@@ -1197,7 +1197,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1216,7 +1216,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1239,7 +1239,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1262,7 +1262,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq16(v *Value) bool {
+func rewriteValueMIPS64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1288,7 +1288,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32(v *Value) bool {
+func rewriteValueMIPS64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1314,7 +1314,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32F(v *Value) bool {
+func rewriteValueMIPS64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -1331,7 +1331,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64(v *Value) bool {
+func rewriteValueMIPS64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1353,7 +1353,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64F(v *Value) bool {
+func rewriteValueMIPS64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -1370,7 +1370,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq8(v *Value) bool {
+func rewriteValueMIPS64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1396,7 +1396,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqB(v *Value) bool {
+func rewriteValueMIPS64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1418,7 +1418,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1440,7 +1440,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq16(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1466,7 +1466,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1492,7 +1492,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1518,7 +1518,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -1535,7 +1535,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1561,7 +1561,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1583,7 +1583,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -1600,7 +1600,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1622,7 +1622,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq8(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1648,7 +1648,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1674,7 +1674,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -1683,7 +1683,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater16(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1704,7 +1704,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater16U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1725,7 +1725,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1746,7 +1746,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -1763,7 +1763,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1784,7 +1784,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64_0(v *Value) bool {
// match: (Greater64 x y)
// cond:
// result: (SGT x y)
@@ -1797,7 +1797,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -1814,7 +1814,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool {
// match: (Greater64U x y)
// cond:
// result: (SGTU x y)
@@ -1827,7 +1827,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater8(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1848,7 +1848,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater8U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1869,7 +1869,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1895,7 +1895,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1921,7 +1921,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1940,7 +1940,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1959,7 +1959,7 @@
return true
}
}
-func rewriteValueMIPS64_OpInterCall(v *Value) bool {
+func rewriteValueMIPS64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -1974,7 +1974,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds idx len)
// cond:
// result: (SGTU len idx)
@@ -1987,7 +1987,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
+func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2005,7 +2005,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2027,7 +2027,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2053,7 +2053,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2079,7 +2079,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2105,7 +2105,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -2122,7 +2122,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2148,7 +2148,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2170,7 +2170,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -2187,7 +2187,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2209,7 +2209,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2235,7 +2235,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2261,7 +2261,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16(v *Value) bool {
+func rewriteValueMIPS64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2282,7 +2282,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16U(v *Value) bool {
+func rewriteValueMIPS64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2303,7 +2303,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32(v *Value) bool {
+func rewriteValueMIPS64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2324,7 +2324,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32F(v *Value) bool {
+func rewriteValueMIPS64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -2341,7 +2341,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32U(v *Value) bool {
+func rewriteValueMIPS64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2362,7 +2362,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64(v *Value) bool {
+func rewriteValueMIPS64_OpLess64_0(v *Value) bool {
// match: (Less64 x y)
// cond:
// result: (SGT y x)
@@ -2375,7 +2375,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64F(v *Value) bool {
+func rewriteValueMIPS64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -2392,7 +2392,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64U(v *Value) bool {
+func rewriteValueMIPS64_OpLess64U_0(v *Value) bool {
// match: (Less64U x y)
// cond:
// result: (SGTU y x)
@@ -2405,7 +2405,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8(v *Value) bool {
+func rewriteValueMIPS64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2426,7 +2426,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8U(v *Value) bool {
+func rewriteValueMIPS64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2447,7 +2447,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLoad(v *Value) bool {
+func rewriteValueMIPS64_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
@@ -2600,7 +2600,7 @@
}
return false
}
-func rewriteValueMIPS64_OpLsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2632,7 +2632,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2664,7 +2664,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2692,7 +2692,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2724,7 +2724,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2756,7 +2756,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2788,7 +2788,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2816,7 +2816,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2848,7 +2848,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2880,7 +2880,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2912,7 +2912,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2940,7 +2940,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2972,7 +2972,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3004,7 +3004,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3036,7 +3036,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3064,7 +3064,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3096,7 +3096,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool {
// match: (ADDV x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ADDVconst [c] x)
@@ -3165,7 +3165,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool {
// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
// cond:
// result: (MOVVaddr [off1+off2] {sym} ptr)
@@ -3251,7 +3251,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool {
// match: (AND x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ANDconst [c] x)
@@ -3303,7 +3303,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVVconst [0])
@@ -3360,7 +3360,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
@@ -3410,7 +3410,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
@@ -3450,7 +3450,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -3500,7 +3500,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
@@ -3540,7 +3540,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
@@ -3742,7 +3742,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
@@ -3792,7 +3792,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVDload [off1+off2] {sym} ptr mem)
@@ -3842,7 +3842,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -3896,7 +3896,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVFload [off1+off2] {sym} ptr mem)
@@ -3946,7 +3946,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
@@ -4000,7 +4000,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
@@ -4050,7 +4050,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
@@ -4114,7 +4114,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -4164,7 +4164,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
@@ -4252,7 +4252,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
@@ -4412,7 +4412,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
@@ -4462,7 +4462,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool {
// match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVVload [off1+off2] {sym} ptr mem)
@@ -4512,7 +4512,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool {
// match: (MOVVreg x)
// cond: x.Uses == 1
// result: (MOVVnop x)
@@ -4540,7 +4540,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool {
// match: (MOVVstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVVstore [off1+off2] {sym} ptr val mem)
@@ -4616,7 +4616,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool {
// match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVVstorezero [off1+off2] {sym} ptr mem)
@@ -4666,7 +4666,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool {
// match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWUload [off1+off2] {sym} ptr mem)
@@ -4716,7 +4716,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool {
// match: (MOVWUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
@@ -4804,7 +4804,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWload [off1+off2] {sym} ptr mem)
@@ -4854,7 +4854,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
@@ -4975,6 +4975,9 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMIPS64MOVWreg_10(v *Value) bool {
// match: (MOVWreg (MOVVconst [c]))
// cond:
// result: (MOVVconst [int64(int32(c))])
@@ -4990,7 +4993,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
@@ -5108,7 +5111,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
@@ -5158,7 +5161,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool {
// match: (NEGV (MOVVconst [c]))
// cond:
// result: (MOVVconst [-c])
@@ -5174,7 +5177,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool {
// match: (NOR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (NORconst [c] x)
@@ -5213,7 +5216,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool {
// match: (NORconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [^(c|d)])
@@ -5230,7 +5233,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool {
// match: (OR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ORconst [c] x)
@@ -5282,7 +5285,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
@@ -5342,7 +5345,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool {
// match: (SGT (MOVVconst [c]) x)
// cond: is32Bit(c)
// result: (SGTconst [c] x)
@@ -5363,7 +5366,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool {
// match: (SGTU (MOVVconst [c]) x)
// cond: is32Bit(c)
// result: (SGTUconst [c] x)
@@ -5384,7 +5387,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool {
// match: (SGTUconst [c] (MOVVconst [d]))
// cond: uint64(c)>uint64(d)
// result: (MOVVconst [1])
@@ -5487,7 +5490,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool {
// match: (SGTconst [c] (MOVVconst [d]))
// cond: int64(c)>int64(d)
// result: (MOVVconst [1])
@@ -5650,6 +5653,9 @@
v.AuxInt = 0
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool {
// match: (SGTconst [c] (MOVWUreg _))
// cond: int64(c) < 0
// result: (MOVVconst [0])
@@ -5702,7 +5708,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool {
// match: (SLLV _ (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (MOVVconst [0])
@@ -5736,7 +5742,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLVconst_0(v *Value) bool {
// match: (SLLVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(d)<<uint64(c)])
@@ -5753,7 +5759,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAV_0(v *Value) bool {
// match: (SRAV x (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (SRAVconst x [63])
@@ -5789,7 +5795,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool {
// match: (SRAVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(d)>>uint64(c)])
@@ -5806,7 +5812,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool {
// match: (SRLV _ (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (MOVVconst [0])
@@ -5840,7 +5846,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool {
// match: (SRLVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(uint64(d)>>uint64(c))])
@@ -5857,7 +5863,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool {
// match: (SUBV x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (SUBVconst [c] x)
@@ -5906,7 +5912,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool {
// match: (SUBVconst [0] x)
// cond:
// result: x
@@ -5974,7 +5980,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool {
// match: (XOR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (XORconst [c] x)
@@ -6025,7 +6031,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
@@ -6087,7 +6093,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMod16(v *Value) bool {
+func rewriteValueMIPS64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6110,7 +6116,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod16u(v *Value) bool {
+func rewriteValueMIPS64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6133,7 +6139,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32(v *Value) bool {
+func rewriteValueMIPS64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6156,7 +6162,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32u(v *Value) bool {
+func rewriteValueMIPS64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6179,7 +6185,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64(v *Value) bool {
+func rewriteValueMIPS64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6198,7 +6204,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64u(v *Value) bool {
+func rewriteValueMIPS64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6217,7 +6223,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8(v *Value) bool {
+func rewriteValueMIPS64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6240,7 +6246,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8u(v *Value) bool {
+func rewriteValueMIPS64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6263,11 +6269,9 @@
return true
}
}
-func rewriteValueMIPS64_OpMove(v *Value) bool {
+func rewriteValueMIPS64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
@@ -6559,6 +6563,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [3] dst src mem)
// cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
@@ -6776,7 +6789,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMul16(v *Value) bool {
+func rewriteValueMIPS64_OpMul16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6795,7 +6808,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul32(v *Value) bool {
+func rewriteValueMIPS64_OpMul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6814,7 +6827,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul32F(v *Value) bool {
+func rewriteValueMIPS64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
@@ -6827,7 +6840,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64(v *Value) bool {
+func rewriteValueMIPS64_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6846,7 +6859,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64F(v *Value) bool {
+func rewriteValueMIPS64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
@@ -6859,7 +6872,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul8(v *Value) bool {
+func rewriteValueMIPS64_OpMul8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6878,7 +6891,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg16(v *Value) bool {
+func rewriteValueMIPS64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGV x)
@@ -6889,7 +6902,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg32(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGV x)
@@ -6900,7 +6913,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
@@ -6911,7 +6924,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg64(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEGV x)
@@ -6922,7 +6935,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
@@ -6933,7 +6946,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg8(v *Value) bool {
+func rewriteValueMIPS64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGV x)
@@ -6944,7 +6957,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq16(v *Value) bool {
+func rewriteValueMIPS64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6970,7 +6983,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -6996,7 +7009,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -7013,7 +7026,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7035,7 +7048,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -7052,7 +7065,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq8(v *Value) bool {
+func rewriteValueMIPS64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7078,7 +7091,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeqB(v *Value) bool {
+func rewriteValueMIPS64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
@@ -7091,7 +7104,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7113,7 +7126,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNilCheck(v *Value) bool {
+func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -7126,7 +7139,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNot(v *Value) bool {
+func rewriteValueMIPS64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
@@ -7138,7 +7151,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOffPtr(v *Value) bool {
+func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVVaddr [off] ptr)
@@ -7165,7 +7178,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr16(v *Value) bool {
+func rewriteValueMIPS64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
@@ -7178,7 +7191,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr32(v *Value) bool {
+func rewriteValueMIPS64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
@@ -7191,7 +7204,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr64(v *Value) bool {
+func rewriteValueMIPS64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
@@ -7204,7 +7217,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr8(v *Value) bool {
+func rewriteValueMIPS64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
@@ -7217,7 +7230,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOrB(v *Value) bool {
+func rewriteValueMIPS64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
@@ -7230,7 +7243,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRound32F(v *Value) bool {
+func rewriteValueMIPS64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
@@ -7242,7 +7255,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRound64F(v *Value) bool {
+func rewriteValueMIPS64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
@@ -7254,7 +7267,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7288,7 +7301,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7322,7 +7335,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7352,7 +7365,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7386,7 +7399,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7420,7 +7433,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7454,7 +7467,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7484,7 +7497,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7518,7 +7531,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7552,7 +7565,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7586,7 +7599,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7616,7 +7629,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7650,7 +7663,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7684,7 +7697,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7718,7 +7731,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7748,7 +7761,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7782,7 +7795,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7814,7 +7827,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7846,7 +7859,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7874,7 +7887,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7906,7 +7919,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7938,7 +7951,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7970,7 +7983,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7998,7 +8011,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8030,7 +8043,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8064,7 +8077,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8098,7 +8111,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8128,7 +8141,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8162,7 +8175,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8196,7 +8209,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8230,7 +8243,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8260,7 +8273,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8294,7 +8307,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSelect0(v *Value) bool {
+func rewriteValueMIPS64_OpSelect0_0(v *Value) bool {
// match: (Select0 (DIVVU _ (MOVVconst [1])))
// cond:
// result: (MOVVconst [0])
@@ -8382,7 +8395,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSelect1(v *Value) bool {
+func rewriteValueMIPS64_OpSelect1_0(v *Value) bool {
// match: (Select1 (MULVU x (MOVVconst [-1])))
// cond:
// result: (NEGV x)
@@ -8587,6 +8600,9 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpSelect1_10(v *Value) bool {
// match: (Select1 (MULVU (MOVVconst [0]) _))
// cond:
// result: (MOVVconst [0])
@@ -8798,6 +8814,9 @@
v.AuxInt = c * d
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpSelect1_20(v *Value) bool {
// match: (Select1 (DIVV (MOVVconst [c]) (MOVVconst [d])))
// cond:
// result: (MOVVconst [int64(c)/int64(d)])
@@ -8844,7 +8863,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
@@ -8855,7 +8874,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
@@ -8866,7 +8885,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
@@ -8877,7 +8896,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
@@ -8888,7 +8907,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
@@ -8899,7 +8918,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
@@ -8910,7 +8929,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSlicemask(v *Value) bool {
+func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -8927,7 +8946,7 @@
return true
}
}
-func rewriteValueMIPS64_OpStaticCall(v *Value) bool {
+func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -8942,7 +8961,7 @@
return true
}
}
-func rewriteValueMIPS64_OpStore(v *Value) bool {
+func rewriteValueMIPS64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
@@ -9047,7 +9066,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSub16(v *Value) bool {
+func rewriteValueMIPS64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBV x y)
@@ -9060,7 +9079,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub32(v *Value) bool {
+func rewriteValueMIPS64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBV x y)
@@ -9073,7 +9092,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub32F(v *Value) bool {
+func rewriteValueMIPS64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
@@ -9086,7 +9105,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub64(v *Value) bool {
+func rewriteValueMIPS64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUBV x y)
@@ -9099,7 +9118,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub64F(v *Value) bool {
+func rewriteValueMIPS64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
@@ -9112,7 +9131,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub8(v *Value) bool {
+func rewriteValueMIPS64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBV x y)
@@ -9125,7 +9144,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSubPtr(v *Value) bool {
+func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUBV x y)
@@ -9138,7 +9157,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -9150,7 +9169,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -9162,7 +9181,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -9174,7 +9193,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
@@ -9186,7 +9205,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
@@ -9198,7 +9217,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
@@ -9210,7 +9229,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor16(v *Value) bool {
+func rewriteValueMIPS64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
@@ -9223,7 +9242,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor32(v *Value) bool {
+func rewriteValueMIPS64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
@@ -9236,7 +9255,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor64(v *Value) bool {
+func rewriteValueMIPS64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
@@ -9249,7 +9268,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor8(v *Value) bool {
+func rewriteValueMIPS64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
@@ -9262,11 +9281,9 @@
return true
}
}
-func rewriteValueMIPS64_OpZero(v *Value) bool {
+func rewriteValueMIPS64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
@@ -9527,6 +9544,15 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [3] ptr mem)
// cond:
// result: (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem)))
@@ -9736,7 +9762,7 @@
}
return false
}
-func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
@@ -9747,7 +9773,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHUreg x)
@@ -9758,7 +9784,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWUreg x)
@@ -9769,7 +9795,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
@@ -9780,7 +9806,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
@@ -9791,7 +9817,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 8788020..70f8de1 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -14,595 +14,595 @@
func rewriteValuePPC64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValuePPC64_OpAdd16(v)
+ return rewriteValuePPC64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValuePPC64_OpAdd32(v)
+ return rewriteValuePPC64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValuePPC64_OpAdd32F(v)
+ return rewriteValuePPC64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValuePPC64_OpAdd64(v)
+ return rewriteValuePPC64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValuePPC64_OpAdd64F(v)
+ return rewriteValuePPC64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValuePPC64_OpAdd8(v)
+ return rewriteValuePPC64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValuePPC64_OpAddPtr(v)
+ return rewriteValuePPC64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValuePPC64_OpAddr(v)
+ return rewriteValuePPC64_OpAddr_0(v)
case OpAnd16:
- return rewriteValuePPC64_OpAnd16(v)
+ return rewriteValuePPC64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValuePPC64_OpAnd32(v)
+ return rewriteValuePPC64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValuePPC64_OpAnd64(v)
+ return rewriteValuePPC64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValuePPC64_OpAnd8(v)
+ return rewriteValuePPC64_OpAnd8_0(v)
case OpAndB:
- return rewriteValuePPC64_OpAndB(v)
+ return rewriteValuePPC64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValuePPC64_OpAtomicAdd32(v)
+ return rewriteValuePPC64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValuePPC64_OpAtomicAdd64(v)
+ return rewriteValuePPC64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValuePPC64_OpAtomicAnd8(v)
+ return rewriteValuePPC64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValuePPC64_OpAtomicCompareAndSwap32(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValuePPC64_OpAtomicCompareAndSwap64(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValuePPC64_OpAtomicExchange32(v)
+ return rewriteValuePPC64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValuePPC64_OpAtomicExchange64(v)
+ return rewriteValuePPC64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValuePPC64_OpAtomicLoad32(v)
+ return rewriteValuePPC64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValuePPC64_OpAtomicLoad64(v)
+ return rewriteValuePPC64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValuePPC64_OpAtomicLoadPtr(v)
+ return rewriteValuePPC64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValuePPC64_OpAtomicOr8(v)
+ return rewriteValuePPC64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValuePPC64_OpAtomicStore32(v)
+ return rewriteValuePPC64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValuePPC64_OpAtomicStore64(v)
+ return rewriteValuePPC64_OpAtomicStore64_0(v)
case OpAvg64u:
- return rewriteValuePPC64_OpAvg64u(v)
+ return rewriteValuePPC64_OpAvg64u_0(v)
case OpClosureCall:
- return rewriteValuePPC64_OpClosureCall(v)
+ return rewriteValuePPC64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValuePPC64_OpCom16(v)
+ return rewriteValuePPC64_OpCom16_0(v)
case OpCom32:
- return rewriteValuePPC64_OpCom32(v)
+ return rewriteValuePPC64_OpCom32_0(v)
case OpCom64:
- return rewriteValuePPC64_OpCom64(v)
+ return rewriteValuePPC64_OpCom64_0(v)
case OpCom8:
- return rewriteValuePPC64_OpCom8(v)
+ return rewriteValuePPC64_OpCom8_0(v)
case OpConst16:
- return rewriteValuePPC64_OpConst16(v)
+ return rewriteValuePPC64_OpConst16_0(v)
case OpConst32:
- return rewriteValuePPC64_OpConst32(v)
+ return rewriteValuePPC64_OpConst32_0(v)
case OpConst32F:
- return rewriteValuePPC64_OpConst32F(v)
+ return rewriteValuePPC64_OpConst32F_0(v)
case OpConst64:
- return rewriteValuePPC64_OpConst64(v)
+ return rewriteValuePPC64_OpConst64_0(v)
case OpConst64F:
- return rewriteValuePPC64_OpConst64F(v)
+ return rewriteValuePPC64_OpConst64F_0(v)
case OpConst8:
- return rewriteValuePPC64_OpConst8(v)
+ return rewriteValuePPC64_OpConst8_0(v)
case OpConstBool:
- return rewriteValuePPC64_OpConstBool(v)
+ return rewriteValuePPC64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValuePPC64_OpConstNil(v)
+ return rewriteValuePPC64_OpConstNil_0(v)
case OpConvert:
- return rewriteValuePPC64_OpConvert(v)
+ return rewriteValuePPC64_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValuePPC64_OpCvt32Fto32(v)
+ return rewriteValuePPC64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValuePPC64_OpCvt32Fto64(v)
+ return rewriteValuePPC64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValuePPC64_OpCvt32Fto64F(v)
+ return rewriteValuePPC64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValuePPC64_OpCvt32to32F(v)
+ return rewriteValuePPC64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValuePPC64_OpCvt32to64F(v)
+ return rewriteValuePPC64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValuePPC64_OpCvt64Fto32(v)
+ return rewriteValuePPC64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValuePPC64_OpCvt64Fto32F(v)
+ return rewriteValuePPC64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValuePPC64_OpCvt64Fto64(v)
+ return rewriteValuePPC64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValuePPC64_OpCvt64to32F(v)
+ return rewriteValuePPC64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValuePPC64_OpCvt64to64F(v)
+ return rewriteValuePPC64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValuePPC64_OpDiv16(v)
+ return rewriteValuePPC64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValuePPC64_OpDiv16u(v)
+ return rewriteValuePPC64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValuePPC64_OpDiv32(v)
+ return rewriteValuePPC64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValuePPC64_OpDiv32F(v)
+ return rewriteValuePPC64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValuePPC64_OpDiv32u(v)
+ return rewriteValuePPC64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValuePPC64_OpDiv64(v)
+ return rewriteValuePPC64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValuePPC64_OpDiv64F(v)
+ return rewriteValuePPC64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValuePPC64_OpDiv64u(v)
+ return rewriteValuePPC64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValuePPC64_OpDiv8(v)
+ return rewriteValuePPC64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValuePPC64_OpDiv8u(v)
+ return rewriteValuePPC64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValuePPC64_OpEq16(v)
+ return rewriteValuePPC64_OpEq16_0(v)
case OpEq32:
- return rewriteValuePPC64_OpEq32(v)
+ return rewriteValuePPC64_OpEq32_0(v)
case OpEq32F:
- return rewriteValuePPC64_OpEq32F(v)
+ return rewriteValuePPC64_OpEq32F_0(v)
case OpEq64:
- return rewriteValuePPC64_OpEq64(v)
+ return rewriteValuePPC64_OpEq64_0(v)
case OpEq64F:
- return rewriteValuePPC64_OpEq64F(v)
+ return rewriteValuePPC64_OpEq64F_0(v)
case OpEq8:
- return rewriteValuePPC64_OpEq8(v)
+ return rewriteValuePPC64_OpEq8_0(v)
case OpEqB:
- return rewriteValuePPC64_OpEqB(v)
+ return rewriteValuePPC64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValuePPC64_OpEqPtr(v)
+ return rewriteValuePPC64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValuePPC64_OpGeq16(v)
+ return rewriteValuePPC64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValuePPC64_OpGeq16U(v)
+ return rewriteValuePPC64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValuePPC64_OpGeq32(v)
+ return rewriteValuePPC64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValuePPC64_OpGeq32F(v)
+ return rewriteValuePPC64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValuePPC64_OpGeq32U(v)
+ return rewriteValuePPC64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValuePPC64_OpGeq64(v)
+ return rewriteValuePPC64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValuePPC64_OpGeq64F(v)
+ return rewriteValuePPC64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValuePPC64_OpGeq64U(v)
+ return rewriteValuePPC64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValuePPC64_OpGeq8(v)
+ return rewriteValuePPC64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValuePPC64_OpGeq8U(v)
+ return rewriteValuePPC64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValuePPC64_OpGetClosurePtr(v)
+ return rewriteValuePPC64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValuePPC64_OpGreater16(v)
+ return rewriteValuePPC64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValuePPC64_OpGreater16U(v)
+ return rewriteValuePPC64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValuePPC64_OpGreater32(v)
+ return rewriteValuePPC64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValuePPC64_OpGreater32F(v)
+ return rewriteValuePPC64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValuePPC64_OpGreater32U(v)
+ return rewriteValuePPC64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValuePPC64_OpGreater64(v)
+ return rewriteValuePPC64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValuePPC64_OpGreater64F(v)
+ return rewriteValuePPC64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValuePPC64_OpGreater64U(v)
+ return rewriteValuePPC64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValuePPC64_OpGreater8(v)
+ return rewriteValuePPC64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValuePPC64_OpGreater8U(v)
+ return rewriteValuePPC64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValuePPC64_OpHmul32(v)
+ return rewriteValuePPC64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValuePPC64_OpHmul32u(v)
+ return rewriteValuePPC64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValuePPC64_OpHmul64(v)
+ return rewriteValuePPC64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValuePPC64_OpHmul64u(v)
+ return rewriteValuePPC64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValuePPC64_OpInterCall(v)
+ return rewriteValuePPC64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValuePPC64_OpIsInBounds(v)
+ return rewriteValuePPC64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValuePPC64_OpIsNonNil(v)
+ return rewriteValuePPC64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValuePPC64_OpIsSliceInBounds(v)
+ return rewriteValuePPC64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValuePPC64_OpLeq16(v)
+ return rewriteValuePPC64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValuePPC64_OpLeq16U(v)
+ return rewriteValuePPC64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValuePPC64_OpLeq32(v)
+ return rewriteValuePPC64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValuePPC64_OpLeq32F(v)
+ return rewriteValuePPC64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValuePPC64_OpLeq32U(v)
+ return rewriteValuePPC64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValuePPC64_OpLeq64(v)
+ return rewriteValuePPC64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValuePPC64_OpLeq64F(v)
+ return rewriteValuePPC64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValuePPC64_OpLeq64U(v)
+ return rewriteValuePPC64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValuePPC64_OpLeq8(v)
+ return rewriteValuePPC64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValuePPC64_OpLeq8U(v)
+ return rewriteValuePPC64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValuePPC64_OpLess16(v)
+ return rewriteValuePPC64_OpLess16_0(v)
case OpLess16U:
- return rewriteValuePPC64_OpLess16U(v)
+ return rewriteValuePPC64_OpLess16U_0(v)
case OpLess32:
- return rewriteValuePPC64_OpLess32(v)
+ return rewriteValuePPC64_OpLess32_0(v)
case OpLess32F:
- return rewriteValuePPC64_OpLess32F(v)
+ return rewriteValuePPC64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValuePPC64_OpLess32U(v)
+ return rewriteValuePPC64_OpLess32U_0(v)
case OpLess64:
- return rewriteValuePPC64_OpLess64(v)
+ return rewriteValuePPC64_OpLess64_0(v)
case OpLess64F:
- return rewriteValuePPC64_OpLess64F(v)
+ return rewriteValuePPC64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValuePPC64_OpLess64U(v)
+ return rewriteValuePPC64_OpLess64U_0(v)
case OpLess8:
- return rewriteValuePPC64_OpLess8(v)
+ return rewriteValuePPC64_OpLess8_0(v)
case OpLess8U:
- return rewriteValuePPC64_OpLess8U(v)
+ return rewriteValuePPC64_OpLess8U_0(v)
case OpLoad:
- return rewriteValuePPC64_OpLoad(v)
+ return rewriteValuePPC64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValuePPC64_OpLsh16x16(v)
+ return rewriteValuePPC64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValuePPC64_OpLsh16x32(v)
+ return rewriteValuePPC64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValuePPC64_OpLsh16x64(v)
+ return rewriteValuePPC64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValuePPC64_OpLsh16x8(v)
+ return rewriteValuePPC64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValuePPC64_OpLsh32x16(v)
+ return rewriteValuePPC64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValuePPC64_OpLsh32x32(v)
+ return rewriteValuePPC64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValuePPC64_OpLsh32x64(v)
+ return rewriteValuePPC64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValuePPC64_OpLsh32x8(v)
+ return rewriteValuePPC64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValuePPC64_OpLsh64x16(v)
+ return rewriteValuePPC64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValuePPC64_OpLsh64x32(v)
+ return rewriteValuePPC64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValuePPC64_OpLsh64x64(v)
+ return rewriteValuePPC64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValuePPC64_OpLsh64x8(v)
+ return rewriteValuePPC64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValuePPC64_OpLsh8x16(v)
+ return rewriteValuePPC64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValuePPC64_OpLsh8x32(v)
+ return rewriteValuePPC64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValuePPC64_OpLsh8x64(v)
+ return rewriteValuePPC64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValuePPC64_OpLsh8x8(v)
+ return rewriteValuePPC64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValuePPC64_OpMod16(v)
+ return rewriteValuePPC64_OpMod16_0(v)
case OpMod16u:
- return rewriteValuePPC64_OpMod16u(v)
+ return rewriteValuePPC64_OpMod16u_0(v)
case OpMod32:
- return rewriteValuePPC64_OpMod32(v)
+ return rewriteValuePPC64_OpMod32_0(v)
case OpMod32u:
- return rewriteValuePPC64_OpMod32u(v)
+ return rewriteValuePPC64_OpMod32u_0(v)
case OpMod64:
- return rewriteValuePPC64_OpMod64(v)
+ return rewriteValuePPC64_OpMod64_0(v)
case OpMod64u:
- return rewriteValuePPC64_OpMod64u(v)
+ return rewriteValuePPC64_OpMod64u_0(v)
case OpMod8:
- return rewriteValuePPC64_OpMod8(v)
+ return rewriteValuePPC64_OpMod8_0(v)
case OpMod8u:
- return rewriteValuePPC64_OpMod8u(v)
+ return rewriteValuePPC64_OpMod8u_0(v)
case OpMove:
- return rewriteValuePPC64_OpMove(v)
+ return rewriteValuePPC64_OpMove_0(v) || rewriteValuePPC64_OpMove_10(v)
case OpMul16:
- return rewriteValuePPC64_OpMul16(v)
+ return rewriteValuePPC64_OpMul16_0(v)
case OpMul32:
- return rewriteValuePPC64_OpMul32(v)
+ return rewriteValuePPC64_OpMul32_0(v)
case OpMul32F:
- return rewriteValuePPC64_OpMul32F(v)
+ return rewriteValuePPC64_OpMul32F_0(v)
case OpMul64:
- return rewriteValuePPC64_OpMul64(v)
+ return rewriteValuePPC64_OpMul64_0(v)
case OpMul64F:
- return rewriteValuePPC64_OpMul64F(v)
+ return rewriteValuePPC64_OpMul64F_0(v)
case OpMul8:
- return rewriteValuePPC64_OpMul8(v)
+ return rewriteValuePPC64_OpMul8_0(v)
case OpNeg16:
- return rewriteValuePPC64_OpNeg16(v)
+ return rewriteValuePPC64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValuePPC64_OpNeg32(v)
+ return rewriteValuePPC64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValuePPC64_OpNeg32F(v)
+ return rewriteValuePPC64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValuePPC64_OpNeg64(v)
+ return rewriteValuePPC64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValuePPC64_OpNeg64F(v)
+ return rewriteValuePPC64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValuePPC64_OpNeg8(v)
+ return rewriteValuePPC64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValuePPC64_OpNeq16(v)
+ return rewriteValuePPC64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValuePPC64_OpNeq32(v)
+ return rewriteValuePPC64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValuePPC64_OpNeq32F(v)
+ return rewriteValuePPC64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValuePPC64_OpNeq64(v)
+ return rewriteValuePPC64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValuePPC64_OpNeq64F(v)
+ return rewriteValuePPC64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValuePPC64_OpNeq8(v)
+ return rewriteValuePPC64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValuePPC64_OpNeqB(v)
+ return rewriteValuePPC64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValuePPC64_OpNeqPtr(v)
+ return rewriteValuePPC64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValuePPC64_OpNilCheck(v)
+ return rewriteValuePPC64_OpNilCheck_0(v)
case OpNot:
- return rewriteValuePPC64_OpNot(v)
+ return rewriteValuePPC64_OpNot_0(v)
case OpOffPtr:
- return rewriteValuePPC64_OpOffPtr(v)
+ return rewriteValuePPC64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValuePPC64_OpOr16(v)
+ return rewriteValuePPC64_OpOr16_0(v)
case OpOr32:
- return rewriteValuePPC64_OpOr32(v)
+ return rewriteValuePPC64_OpOr32_0(v)
case OpOr64:
- return rewriteValuePPC64_OpOr64(v)
+ return rewriteValuePPC64_OpOr64_0(v)
case OpOr8:
- return rewriteValuePPC64_OpOr8(v)
+ return rewriteValuePPC64_OpOr8_0(v)
case OpOrB:
- return rewriteValuePPC64_OpOrB(v)
+ return rewriteValuePPC64_OpOrB_0(v)
case OpPPC64ADD:
- return rewriteValuePPC64_OpPPC64ADD(v)
+ return rewriteValuePPC64_OpPPC64ADD_0(v)
case OpPPC64ADDconst:
- return rewriteValuePPC64_OpPPC64ADDconst(v)
+ return rewriteValuePPC64_OpPPC64ADDconst_0(v)
case OpPPC64AND:
- return rewriteValuePPC64_OpPPC64AND(v)
+ return rewriteValuePPC64_OpPPC64AND_0(v)
case OpPPC64ANDconst:
- return rewriteValuePPC64_OpPPC64ANDconst(v)
+ return rewriteValuePPC64_OpPPC64ANDconst_0(v)
case OpPPC64CMP:
- return rewriteValuePPC64_OpPPC64CMP(v)
+ return rewriteValuePPC64_OpPPC64CMP_0(v)
case OpPPC64CMPU:
- return rewriteValuePPC64_OpPPC64CMPU(v)
+ return rewriteValuePPC64_OpPPC64CMPU_0(v)
case OpPPC64CMPUconst:
- return rewriteValuePPC64_OpPPC64CMPUconst(v)
+ return rewriteValuePPC64_OpPPC64CMPUconst_0(v)
case OpPPC64CMPW:
- return rewriteValuePPC64_OpPPC64CMPW(v)
+ return rewriteValuePPC64_OpPPC64CMPW_0(v)
case OpPPC64CMPWU:
- return rewriteValuePPC64_OpPPC64CMPWU(v)
+ return rewriteValuePPC64_OpPPC64CMPWU_0(v)
case OpPPC64CMPWUconst:
- return rewriteValuePPC64_OpPPC64CMPWUconst(v)
+ return rewriteValuePPC64_OpPPC64CMPWUconst_0(v)
case OpPPC64CMPWconst:
- return rewriteValuePPC64_OpPPC64CMPWconst(v)
+ return rewriteValuePPC64_OpPPC64CMPWconst_0(v)
case OpPPC64CMPconst:
- return rewriteValuePPC64_OpPPC64CMPconst(v)
+ return rewriteValuePPC64_OpPPC64CMPconst_0(v)
case OpPPC64Equal:
- return rewriteValuePPC64_OpPPC64Equal(v)
+ return rewriteValuePPC64_OpPPC64Equal_0(v)
case OpPPC64FADD:
- return rewriteValuePPC64_OpPPC64FADD(v)
+ return rewriteValuePPC64_OpPPC64FADD_0(v)
case OpPPC64FADDS:
- return rewriteValuePPC64_OpPPC64FADDS(v)
+ return rewriteValuePPC64_OpPPC64FADDS_0(v)
case OpPPC64FMOVDload:
- return rewriteValuePPC64_OpPPC64FMOVDload(v)
+ return rewriteValuePPC64_OpPPC64FMOVDload_0(v)
case OpPPC64FMOVDstore:
- return rewriteValuePPC64_OpPPC64FMOVDstore(v)
+ return rewriteValuePPC64_OpPPC64FMOVDstore_0(v)
case OpPPC64FMOVSload:
- return rewriteValuePPC64_OpPPC64FMOVSload(v)
+ return rewriteValuePPC64_OpPPC64FMOVSload_0(v)
case OpPPC64FMOVSstore:
- return rewriteValuePPC64_OpPPC64FMOVSstore(v)
+ return rewriteValuePPC64_OpPPC64FMOVSstore_0(v)
case OpPPC64FSUB:
- return rewriteValuePPC64_OpPPC64FSUB(v)
+ return rewriteValuePPC64_OpPPC64FSUB_0(v)
case OpPPC64FSUBS:
- return rewriteValuePPC64_OpPPC64FSUBS(v)
+ return rewriteValuePPC64_OpPPC64FSUBS_0(v)
case OpPPC64GreaterEqual:
- return rewriteValuePPC64_OpPPC64GreaterEqual(v)
+ return rewriteValuePPC64_OpPPC64GreaterEqual_0(v)
case OpPPC64GreaterThan:
- return rewriteValuePPC64_OpPPC64GreaterThan(v)
+ return rewriteValuePPC64_OpPPC64GreaterThan_0(v)
case OpPPC64LessEqual:
- return rewriteValuePPC64_OpPPC64LessEqual(v)
+ return rewriteValuePPC64_OpPPC64LessEqual_0(v)
case OpPPC64LessThan:
- return rewriteValuePPC64_OpPPC64LessThan(v)
+ return rewriteValuePPC64_OpPPC64LessThan_0(v)
case OpPPC64MOVBZload:
- return rewriteValuePPC64_OpPPC64MOVBZload(v)
+ return rewriteValuePPC64_OpPPC64MOVBZload_0(v)
case OpPPC64MOVBZreg:
- return rewriteValuePPC64_OpPPC64MOVBZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVBZreg_0(v)
case OpPPC64MOVBreg:
- return rewriteValuePPC64_OpPPC64MOVBreg(v)
+ return rewriteValuePPC64_OpPPC64MOVBreg_0(v)
case OpPPC64MOVBstore:
- return rewriteValuePPC64_OpPPC64MOVBstore(v)
+ return rewriteValuePPC64_OpPPC64MOVBstore_0(v)
case OpPPC64MOVBstorezero:
- return rewriteValuePPC64_OpPPC64MOVBstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVBstorezero_0(v)
case OpPPC64MOVDload:
- return rewriteValuePPC64_OpPPC64MOVDload(v)
+ return rewriteValuePPC64_OpPPC64MOVDload_0(v)
case OpPPC64MOVDstore:
- return rewriteValuePPC64_OpPPC64MOVDstore(v)
+ return rewriteValuePPC64_OpPPC64MOVDstore_0(v)
case OpPPC64MOVDstorezero:
- return rewriteValuePPC64_OpPPC64MOVDstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVDstorezero_0(v)
case OpPPC64MOVHZload:
- return rewriteValuePPC64_OpPPC64MOVHZload(v)
+ return rewriteValuePPC64_OpPPC64MOVHZload_0(v)
case OpPPC64MOVHZreg:
- return rewriteValuePPC64_OpPPC64MOVHZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVHZreg_0(v)
case OpPPC64MOVHload:
- return rewriteValuePPC64_OpPPC64MOVHload(v)
+ return rewriteValuePPC64_OpPPC64MOVHload_0(v)
case OpPPC64MOVHreg:
- return rewriteValuePPC64_OpPPC64MOVHreg(v)
+ return rewriteValuePPC64_OpPPC64MOVHreg_0(v)
case OpPPC64MOVHstore:
- return rewriteValuePPC64_OpPPC64MOVHstore(v)
+ return rewriteValuePPC64_OpPPC64MOVHstore_0(v)
case OpPPC64MOVHstorezero:
- return rewriteValuePPC64_OpPPC64MOVHstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVHstorezero_0(v)
case OpPPC64MOVWZload:
- return rewriteValuePPC64_OpPPC64MOVWZload(v)
+ return rewriteValuePPC64_OpPPC64MOVWZload_0(v)
case OpPPC64MOVWZreg:
- return rewriteValuePPC64_OpPPC64MOVWZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVWZreg_0(v)
case OpPPC64MOVWload:
- return rewriteValuePPC64_OpPPC64MOVWload(v)
+ return rewriteValuePPC64_OpPPC64MOVWload_0(v)
case OpPPC64MOVWreg:
- return rewriteValuePPC64_OpPPC64MOVWreg(v)
+ return rewriteValuePPC64_OpPPC64MOVWreg_0(v)
case OpPPC64MOVWstore:
- return rewriteValuePPC64_OpPPC64MOVWstore(v)
+ return rewriteValuePPC64_OpPPC64MOVWstore_0(v)
case OpPPC64MOVWstorezero:
- return rewriteValuePPC64_OpPPC64MOVWstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVWstorezero_0(v)
case OpPPC64MaskIfNotCarry:
- return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v)
+ return rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v)
case OpPPC64NotEqual:
- return rewriteValuePPC64_OpPPC64NotEqual(v)
+ return rewriteValuePPC64_OpPPC64NotEqual_0(v)
case OpPPC64OR:
- return rewriteValuePPC64_OpPPC64OR(v)
+ return rewriteValuePPC64_OpPPC64OR_0(v)
case OpPPC64ORN:
- return rewriteValuePPC64_OpPPC64ORN(v)
+ return rewriteValuePPC64_OpPPC64ORN_0(v)
case OpPPC64ORconst:
- return rewriteValuePPC64_OpPPC64ORconst(v)
+ return rewriteValuePPC64_OpPPC64ORconst_0(v)
case OpPPC64SUB:
- return rewriteValuePPC64_OpPPC64SUB(v)
+ return rewriteValuePPC64_OpPPC64SUB_0(v)
case OpPPC64XOR:
- return rewriteValuePPC64_OpPPC64XOR(v)
+ return rewriteValuePPC64_OpPPC64XOR_0(v)
case OpPPC64XORconst:
- return rewriteValuePPC64_OpPPC64XORconst(v)
+ return rewriteValuePPC64_OpPPC64XORconst_0(v)
case OpRound32F:
- return rewriteValuePPC64_OpRound32F(v)
+ return rewriteValuePPC64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValuePPC64_OpRound64F(v)
+ return rewriteValuePPC64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValuePPC64_OpRsh16Ux16(v)
+ return rewriteValuePPC64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValuePPC64_OpRsh16Ux32(v)
+ return rewriteValuePPC64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValuePPC64_OpRsh16Ux64(v)
+ return rewriteValuePPC64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValuePPC64_OpRsh16Ux8(v)
+ return rewriteValuePPC64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValuePPC64_OpRsh16x16(v)
+ return rewriteValuePPC64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValuePPC64_OpRsh16x32(v)
+ return rewriteValuePPC64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValuePPC64_OpRsh16x64(v)
+ return rewriteValuePPC64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValuePPC64_OpRsh16x8(v)
+ return rewriteValuePPC64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValuePPC64_OpRsh32Ux16(v)
+ return rewriteValuePPC64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValuePPC64_OpRsh32Ux32(v)
+ return rewriteValuePPC64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValuePPC64_OpRsh32Ux64(v)
+ return rewriteValuePPC64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValuePPC64_OpRsh32Ux8(v)
+ return rewriteValuePPC64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValuePPC64_OpRsh32x16(v)
+ return rewriteValuePPC64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValuePPC64_OpRsh32x32(v)
+ return rewriteValuePPC64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValuePPC64_OpRsh32x64(v)
+ return rewriteValuePPC64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValuePPC64_OpRsh32x8(v)
+ return rewriteValuePPC64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValuePPC64_OpRsh64Ux16(v)
+ return rewriteValuePPC64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValuePPC64_OpRsh64Ux32(v)
+ return rewriteValuePPC64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValuePPC64_OpRsh64Ux64(v)
+ return rewriteValuePPC64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValuePPC64_OpRsh64Ux8(v)
+ return rewriteValuePPC64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValuePPC64_OpRsh64x16(v)
+ return rewriteValuePPC64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValuePPC64_OpRsh64x32(v)
+ return rewriteValuePPC64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValuePPC64_OpRsh64x64(v)
+ return rewriteValuePPC64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValuePPC64_OpRsh64x8(v)
+ return rewriteValuePPC64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValuePPC64_OpRsh8Ux16(v)
+ return rewriteValuePPC64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValuePPC64_OpRsh8Ux32(v)
+ return rewriteValuePPC64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValuePPC64_OpRsh8Ux64(v)
+ return rewriteValuePPC64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValuePPC64_OpRsh8Ux8(v)
+ return rewriteValuePPC64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValuePPC64_OpRsh8x16(v)
+ return rewriteValuePPC64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValuePPC64_OpRsh8x32(v)
+ return rewriteValuePPC64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValuePPC64_OpRsh8x64(v)
+ return rewriteValuePPC64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValuePPC64_OpRsh8x8(v)
+ return rewriteValuePPC64_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValuePPC64_OpSignExt16to32(v)
+ return rewriteValuePPC64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValuePPC64_OpSignExt16to64(v)
+ return rewriteValuePPC64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValuePPC64_OpSignExt32to64(v)
+ return rewriteValuePPC64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValuePPC64_OpSignExt8to16(v)
+ return rewriteValuePPC64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValuePPC64_OpSignExt8to32(v)
+ return rewriteValuePPC64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValuePPC64_OpSignExt8to64(v)
+ return rewriteValuePPC64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValuePPC64_OpSlicemask(v)
+ return rewriteValuePPC64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValuePPC64_OpSqrt(v)
+ return rewriteValuePPC64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValuePPC64_OpStaticCall(v)
+ return rewriteValuePPC64_OpStaticCall_0(v)
case OpStore:
- return rewriteValuePPC64_OpStore(v)
+ return rewriteValuePPC64_OpStore_0(v)
case OpSub16:
- return rewriteValuePPC64_OpSub16(v)
+ return rewriteValuePPC64_OpSub16_0(v)
case OpSub32:
- return rewriteValuePPC64_OpSub32(v)
+ return rewriteValuePPC64_OpSub32_0(v)
case OpSub32F:
- return rewriteValuePPC64_OpSub32F(v)
+ return rewriteValuePPC64_OpSub32F_0(v)
case OpSub64:
- return rewriteValuePPC64_OpSub64(v)
+ return rewriteValuePPC64_OpSub64_0(v)
case OpSub64F:
- return rewriteValuePPC64_OpSub64F(v)
+ return rewriteValuePPC64_OpSub64F_0(v)
case OpSub8:
- return rewriteValuePPC64_OpSub8(v)
+ return rewriteValuePPC64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValuePPC64_OpSubPtr(v)
+ return rewriteValuePPC64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValuePPC64_OpTrunc16to8(v)
+ return rewriteValuePPC64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValuePPC64_OpTrunc32to16(v)
+ return rewriteValuePPC64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValuePPC64_OpTrunc32to8(v)
+ return rewriteValuePPC64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValuePPC64_OpTrunc64to16(v)
+ return rewriteValuePPC64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValuePPC64_OpTrunc64to32(v)
+ return rewriteValuePPC64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValuePPC64_OpTrunc64to8(v)
+ return rewriteValuePPC64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValuePPC64_OpXor16(v)
+ return rewriteValuePPC64_OpXor16_0(v)
case OpXor32:
- return rewriteValuePPC64_OpXor32(v)
+ return rewriteValuePPC64_OpXor32_0(v)
case OpXor64:
- return rewriteValuePPC64_OpXor64(v)
+ return rewriteValuePPC64_OpXor64_0(v)
case OpXor8:
- return rewriteValuePPC64_OpXor8(v)
+ return rewriteValuePPC64_OpXor8_0(v)
case OpZero:
- return rewriteValuePPC64_OpZero(v)
+ return rewriteValuePPC64_OpZero_0(v) || rewriteValuePPC64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValuePPC64_OpZeroExt16to32(v)
+ return rewriteValuePPC64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValuePPC64_OpZeroExt16to64(v)
+ return rewriteValuePPC64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValuePPC64_OpZeroExt32to64(v)
+ return rewriteValuePPC64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValuePPC64_OpZeroExt8to16(v)
+ return rewriteValuePPC64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValuePPC64_OpZeroExt8to32(v)
+ return rewriteValuePPC64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValuePPC64_OpZeroExt8to64(v)
+ return rewriteValuePPC64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValuePPC64_OpAdd16(v *Value) bool {
+func rewriteValuePPC64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
@@ -615,7 +615,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
@@ -628,7 +628,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd32F(v *Value) bool {
+func rewriteValuePPC64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
@@ -641,7 +641,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
@@ -654,7 +654,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd64F(v *Value) bool {
+func rewriteValuePPC64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADD x y)
@@ -667,7 +667,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd8(v *Value) bool {
+func rewriteValuePPC64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
@@ -680,7 +680,7 @@
return true
}
}
-func rewriteValuePPC64_OpAddPtr(v *Value) bool {
+func rewriteValuePPC64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
@@ -693,7 +693,7 @@
return true
}
}
-func rewriteValuePPC64_OpAddr(v *Value) bool {
+func rewriteValuePPC64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
@@ -706,7 +706,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd16(v *Value) bool {
+func rewriteValuePPC64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
@@ -719,7 +719,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd32(v *Value) bool {
+func rewriteValuePPC64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
@@ -732,7 +732,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd64(v *Value) bool {
+func rewriteValuePPC64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
@@ -745,7 +745,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
@@ -758,7 +758,7 @@
return true
}
}
-func rewriteValuePPC64_OpAndB(v *Value) bool {
+func rewriteValuePPC64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
@@ -771,7 +771,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd32 ptr val mem)
@@ -786,7 +786,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool {
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (LoweredAtomicAdd64 ptr val mem)
@@ -801,7 +801,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (LoweredAtomicAnd8 ptr val mem)
@@ -816,7 +816,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -833,7 +833,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -850,7 +850,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
@@ -865,7 +865,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
@@ -880,7 +880,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LoweredAtomicLoad32 ptr mem)
@@ -893,7 +893,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (LoweredAtomicLoad64 ptr mem)
@@ -906,7 +906,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LoweredAtomicLoadPtr ptr mem)
@@ -919,7 +919,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicOr8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (LoweredAtomicOr8 ptr val mem)
@@ -934,7 +934,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (LoweredAtomicStore32 ptr val mem)
@@ -949,7 +949,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (LoweredAtomicStore64 ptr val mem)
@@ -964,7 +964,7 @@
return true
}
}
-func rewriteValuePPC64_OpAvg64u(v *Value) bool {
+func rewriteValuePPC64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
@@ -986,7 +986,7 @@
return true
}
}
-func rewriteValuePPC64_OpClosureCall(v *Value) bool {
+func rewriteValuePPC64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -1003,7 +1003,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom16(v *Value) bool {
+func rewriteValuePPC64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOR x x)
@@ -1015,7 +1015,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom32(v *Value) bool {
+func rewriteValuePPC64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOR x x)
@@ -1027,7 +1027,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom64(v *Value) bool {
+func rewriteValuePPC64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOR x x)
@@ -1039,7 +1039,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom8(v *Value) bool {
+func rewriteValuePPC64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOR x x)
@@ -1051,7 +1051,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst16(v *Value) bool {
+func rewriteValuePPC64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
@@ -1062,7 +1062,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst32(v *Value) bool {
+func rewriteValuePPC64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
@@ -1073,7 +1073,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst32F(v *Value) bool {
+func rewriteValuePPC64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
@@ -1084,7 +1084,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst64(v *Value) bool {
+func rewriteValuePPC64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
@@ -1095,7 +1095,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst64F(v *Value) bool {
+func rewriteValuePPC64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
@@ -1106,7 +1106,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst8(v *Value) bool {
+func rewriteValuePPC64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
@@ -1117,7 +1117,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstBool(v *Value) bool {
+func rewriteValuePPC64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
@@ -1128,7 +1128,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstNil(v *Value) bool {
+func rewriteValuePPC64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
@@ -1138,7 +1138,7 @@
return true
}
}
-func rewriteValuePPC64_OpConvert(v *Value) bool {
+func rewriteValuePPC64_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVDconvert <t> x mem)
@@ -1153,7 +1153,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1170,7 +1170,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1187,7 +1187,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: x
@@ -1199,7 +1199,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1220,7 +1220,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1239,7 +1239,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1256,7 +1256,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (FRSP x)
@@ -1267,7 +1267,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1284,7 +1284,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1303,7 +1303,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1320,7 +1320,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv16(v *Value) bool {
+func rewriteValuePPC64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1341,7 +1341,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv16u(v *Value) bool {
+func rewriteValuePPC64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1362,7 +1362,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32(v *Value) bool {
+func rewriteValuePPC64_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVW x y)
@@ -1375,7 +1375,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32F(v *Value) bool {
+func rewriteValuePPC64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
@@ -1388,7 +1388,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32u(v *Value) bool {
+func rewriteValuePPC64_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (DIVWU x y)
@@ -1401,7 +1401,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64(v *Value) bool {
+func rewriteValuePPC64_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIVD x y)
@@ -1414,7 +1414,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64F(v *Value) bool {
+func rewriteValuePPC64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIV x y)
@@ -1427,7 +1427,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64u(v *Value) bool {
+func rewriteValuePPC64_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (DIVDU x y)
@@ -1440,7 +1440,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv8(v *Value) bool {
+func rewriteValuePPC64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1461,7 +1461,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv8u(v *Value) bool {
+func rewriteValuePPC64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1482,7 +1482,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq16(v *Value) bool {
+func rewriteValuePPC64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1525,7 +1525,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32(v *Value) bool {
+func rewriteValuePPC64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
@@ -1542,7 +1542,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32F(v *Value) bool {
+func rewriteValuePPC64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
@@ -1559,7 +1559,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64(v *Value) bool {
+func rewriteValuePPC64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
@@ -1576,7 +1576,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64F(v *Value) bool {
+func rewriteValuePPC64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
@@ -1593,7 +1593,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq8(v *Value) bool {
+func rewriteValuePPC64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1636,7 +1636,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqB(v *Value) bool {
+func rewriteValuePPC64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1656,7 +1656,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqPtr(v *Value) bool {
+func rewriteValuePPC64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
@@ -1673,7 +1673,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq16(v *Value) bool {
+func rewriteValuePPC64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1696,7 +1696,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq16U(v *Value) bool {
+func rewriteValuePPC64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1719,7 +1719,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32(v *Value) bool {
+func rewriteValuePPC64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
@@ -1736,7 +1736,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32F(v *Value) bool {
+func rewriteValuePPC64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
@@ -1753,7 +1753,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32U(v *Value) bool {
+func rewriteValuePPC64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
@@ -1770,7 +1770,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64(v *Value) bool {
+func rewriteValuePPC64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
@@ -1787,7 +1787,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64F(v *Value) bool {
+func rewriteValuePPC64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
@@ -1804,7 +1804,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64U(v *Value) bool {
+func rewriteValuePPC64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
@@ -1821,7 +1821,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq8(v *Value) bool {
+func rewriteValuePPC64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1844,7 +1844,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq8U(v *Value) bool {
+func rewriteValuePPC64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1867,7 +1867,7 @@
return true
}
}
-func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool {
+func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -1876,7 +1876,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater16(v *Value) bool {
+func rewriteValuePPC64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1899,7 +1899,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater16U(v *Value) bool {
+func rewriteValuePPC64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1922,7 +1922,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32(v *Value) bool {
+func rewriteValuePPC64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
@@ -1939,7 +1939,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32F(v *Value) bool {
+func rewriteValuePPC64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
@@ -1956,7 +1956,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32U(v *Value) bool {
+func rewriteValuePPC64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
@@ -1973,7 +1973,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64(v *Value) bool {
+func rewriteValuePPC64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
@@ -1990,7 +1990,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64F(v *Value) bool {
+func rewriteValuePPC64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
@@ -2007,7 +2007,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64U(v *Value) bool {
+func rewriteValuePPC64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
@@ -2024,7 +2024,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater8(v *Value) bool {
+func rewriteValuePPC64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2047,7 +2047,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater8U(v *Value) bool {
+func rewriteValuePPC64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2070,7 +2070,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul32(v *Value) bool {
+func rewriteValuePPC64_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (MULHW x y)
@@ -2083,7 +2083,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul32u(v *Value) bool {
+func rewriteValuePPC64_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (MULHWU x y)
@@ -2096,7 +2096,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul64(v *Value) bool {
+func rewriteValuePPC64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULHD x y)
@@ -2109,7 +2109,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul64u(v *Value) bool {
+func rewriteValuePPC64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (MULHDU x y)
@@ -2122,7 +2122,7 @@
return true
}
}
-func rewriteValuePPC64_OpInterCall(v *Value) bool {
+func rewriteValuePPC64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -2137,7 +2137,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
@@ -2154,7 +2154,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsNonNil(v *Value) bool {
+func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
@@ -2170,7 +2170,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
@@ -2187,7 +2187,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16(v *Value) bool {
+func rewriteValuePPC64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2210,7 +2210,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16U(v *Value) bool {
+func rewriteValuePPC64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2233,7 +2233,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32(v *Value) bool {
+func rewriteValuePPC64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
@@ -2250,7 +2250,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32F(v *Value) bool {
+func rewriteValuePPC64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
@@ -2267,7 +2267,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32U(v *Value) bool {
+func rewriteValuePPC64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
@@ -2284,7 +2284,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64(v *Value) bool {
+func rewriteValuePPC64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
@@ -2301,7 +2301,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64F(v *Value) bool {
+func rewriteValuePPC64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
@@ -2318,7 +2318,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64U(v *Value) bool {
+func rewriteValuePPC64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
@@ -2335,7 +2335,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8(v *Value) bool {
+func rewriteValuePPC64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2358,7 +2358,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8U(v *Value) bool {
+func rewriteValuePPC64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2381,7 +2381,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16(v *Value) bool {
+func rewriteValuePPC64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2404,7 +2404,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16U(v *Value) bool {
+func rewriteValuePPC64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2427,7 +2427,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32(v *Value) bool {
+func rewriteValuePPC64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
@@ -2444,7 +2444,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32F(v *Value) bool {
+func rewriteValuePPC64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
@@ -2461,7 +2461,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32U(v *Value) bool {
+func rewriteValuePPC64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
@@ -2478,7 +2478,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64(v *Value) bool {
+func rewriteValuePPC64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
@@ -2495,7 +2495,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64F(v *Value) bool {
+func rewriteValuePPC64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
@@ -2512,7 +2512,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64U(v *Value) bool {
+func rewriteValuePPC64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
@@ -2529,7 +2529,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8(v *Value) bool {
+func rewriteValuePPC64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2552,7 +2552,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8U(v *Value) bool {
+func rewriteValuePPC64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2575,7 +2575,7 @@
return true
}
}
-func rewriteValuePPC64_OpLoad(v *Value) bool {
+func rewriteValuePPC64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2734,7 +2734,7 @@
}
return false
}
-func rewriteValuePPC64_OpLsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2761,7 +2761,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2824,7 +2824,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2901,7 +2901,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2928,7 +2928,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2955,7 +2955,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3018,7 +3018,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3095,7 +3095,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3122,7 +3122,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3149,7 +3149,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3212,7 +3212,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3289,7 +3289,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3316,7 +3316,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3343,7 +3343,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3406,7 +3406,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3483,7 +3483,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3510,7 +3510,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod16(v *Value) bool {
+func rewriteValuePPC64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3531,7 +3531,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod16u(v *Value) bool {
+func rewriteValuePPC64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3552,7 +3552,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod32(v *Value) bool {
+func rewriteValuePPC64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3575,7 +3575,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod32u(v *Value) bool {
+func rewriteValuePPC64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3598,7 +3598,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod64(v *Value) bool {
+func rewriteValuePPC64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3621,7 +3621,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod64u(v *Value) bool {
+func rewriteValuePPC64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3644,7 +3644,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod8(v *Value) bool {
+func rewriteValuePPC64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3665,7 +3665,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod8u(v *Value) bool {
+func rewriteValuePPC64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3686,7 +3686,7 @@
return true
}
}
-func rewriteValuePPC64_OpMove(v *Value) bool {
+func rewriteValuePPC64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3933,6 +3933,9 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValuePPC64_OpMove_10(v *Value) bool {
// match: (Move [s] dst src mem)
// cond: s > 8
// result: (LoweredMove [s] dst src mem)
@@ -3953,7 +3956,7 @@
}
return false
}
-func rewriteValuePPC64_OpMul16(v *Value) bool {
+func rewriteValuePPC64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULLW x y)
@@ -3966,7 +3969,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul32(v *Value) bool {
+func rewriteValuePPC64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULLW x y)
@@ -3979,7 +3982,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul32F(v *Value) bool {
+func rewriteValuePPC64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
@@ -3992,7 +3995,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul64(v *Value) bool {
+func rewriteValuePPC64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULLD x y)
@@ -4005,7 +4008,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul64F(v *Value) bool {
+func rewriteValuePPC64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMUL x y)
@@ -4018,7 +4021,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul8(v *Value) bool {
+func rewriteValuePPC64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULLW x y)
@@ -4031,7 +4034,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg16(v *Value) bool {
+func rewriteValuePPC64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
@@ -4042,7 +4045,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg32(v *Value) bool {
+func rewriteValuePPC64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
@@ -4053,7 +4056,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg32F(v *Value) bool {
+func rewriteValuePPC64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEG x)
@@ -4064,7 +4067,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg64(v *Value) bool {
+func rewriteValuePPC64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
@@ -4075,7 +4078,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg64F(v *Value) bool {
+func rewriteValuePPC64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEG x)
@@ -4086,7 +4089,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg8(v *Value) bool {
+func rewriteValuePPC64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
@@ -4097,7 +4100,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq16(v *Value) bool {
+func rewriteValuePPC64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4140,7 +4143,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32(v *Value) bool {
+func rewriteValuePPC64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
@@ -4157,7 +4160,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32F(v *Value) bool {
+func rewriteValuePPC64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
@@ -4174,7 +4177,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64(v *Value) bool {
+func rewriteValuePPC64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
@@ -4191,7 +4194,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64F(v *Value) bool {
+func rewriteValuePPC64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
@@ -4208,7 +4211,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq8(v *Value) bool {
+func rewriteValuePPC64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4251,7 +4254,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeqB(v *Value) bool {
+func rewriteValuePPC64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
@@ -4264,7 +4267,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeqPtr(v *Value) bool {
+func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
@@ -4281,7 +4284,7 @@
return true
}
}
-func rewriteValuePPC64_OpNilCheck(v *Value) bool {
+func rewriteValuePPC64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -4294,7 +4297,7 @@
return true
}
}
-func rewriteValuePPC64_OpNot(v *Value) bool {
+func rewriteValuePPC64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
@@ -4306,7 +4309,7 @@
return true
}
}
-func rewriteValuePPC64_OpOffPtr(v *Value) bool {
+func rewriteValuePPC64_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4325,7 +4328,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr16(v *Value) bool {
+func rewriteValuePPC64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
@@ -4338,7 +4341,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr32(v *Value) bool {
+func rewriteValuePPC64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
@@ -4351,7 +4354,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr64(v *Value) bool {
+func rewriteValuePPC64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
@@ -4364,7 +4367,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr8(v *Value) bool {
+func rewriteValuePPC64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
@@ -4377,7 +4380,7 @@
return true
}
}
-func rewriteValuePPC64_OpOrB(v *Value) bool {
+func rewriteValuePPC64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
@@ -4390,7 +4393,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool {
// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
@@ -4533,7 +4536,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool {
// match: (ADDconst [c] (ADDconst [d] x))
// cond: is32Bit(c+d)
// result: (ADDconst [c+d] x)
@@ -4586,7 +4589,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64AND(v *Value) bool {
+func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool {
// match: (AND x (NOR y y))
// cond:
// result: (ANDN x y)
@@ -4769,7 +4772,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool {
// match: (ANDconst [c] (ANDconst [d] x))
// cond:
// result: (ANDconst [c&d] x)
@@ -4908,7 +4911,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
@@ -4951,7 +4954,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPU x (MOVDconst [c]))
@@ -4994,7 +4997,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool {
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: int64(x)==int64(y)
// result: (FlagEQ)
@@ -5045,7 +5048,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVWreg y))
@@ -5118,7 +5121,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPWU x (MOVWZreg y))
@@ -5191,7 +5194,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool {
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -5242,7 +5245,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -5293,7 +5296,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: int64(x)==int64(y)
// result: (FlagEQ)
@@ -5344,7 +5347,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64Equal(v *Value) bool {
+func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -5396,7 +5399,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool {
// match: (FADD (FMUL x y) z)
// cond:
// result: (FMADD x y z)
@@ -5433,7 +5436,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool {
// match: (FADDS (FMULS x y) z)
// cond:
// result: (FMADDS x y z)
@@ -5470,7 +5473,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5520,7 +5523,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is16Bit(off1+off2)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -5574,7 +5577,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5624,7 +5627,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is16Bit(off1+off2)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -5678,7 +5681,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool {
// match: (FSUB (FMUL x y) z)
// cond:
// result: (FMSUB x y z)
@@ -5698,7 +5701,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool {
// match: (FSUBS (FMULS x y) z)
// cond:
// result: (FMSUBS x y z)
@@ -5718,7 +5721,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -5770,7 +5773,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -5822,7 +5825,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
@@ -5874,7 +5877,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -5926,7 +5929,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool {
// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -5976,7 +5979,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool {
// match: (MOVBZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFF
// result: y
@@ -6048,7 +6051,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool {
// match: (MOVBreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0x7F
// result: y
@@ -6107,7 +6110,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVBstore [off1+off2] {sym} x val mem)
@@ -6226,7 +6229,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVBstorezero [off1+off2] {sym} x mem)
@@ -6276,7 +6279,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6326,7 +6329,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} x val mem)
@@ -6403,7 +6406,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool {
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVDstorezero [off1+off2] {sym} x mem)
@@ -6453,7 +6456,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool {
// match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6503,7 +6506,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool {
// match: (MOVHZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFF
// result: y
@@ -6588,7 +6591,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6638,7 +6641,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool {
// match: (MOVHreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0x7FFF
// result: y
@@ -6723,7 +6726,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVHstore [off1+off2] {sym} x val mem)
@@ -6842,7 +6845,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVHstorezero [off1+off2] {sym} x mem)
@@ -6892,7 +6895,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool {
// match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -6942,7 +6945,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool {
// match: (MOVWZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFFFFFF
// result: y
@@ -7056,7 +7059,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
@@ -7106,7 +7109,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool {
// match: (MOVWreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFF
// result: y
@@ -7220,7 +7223,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVWstore [off1+off2] {sym} x val mem)
@@ -7339,7 +7342,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVWstorezero [off1+off2] {sym} x mem)
@@ -7389,7 +7392,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool {
// match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _)))
// cond: c < 0 && d > 0 && c + d < 0
// result: (MOVDconst [-1])
@@ -7413,7 +7416,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVDconst [0])
@@ -7465,7 +7468,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool {
// match: (OR (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
@@ -7644,7 +7647,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORN(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool {
// match: (ORN x (MOVDconst [-1]))
// cond:
// result: x
@@ -7664,7 +7667,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool {
// match: (ORconst [c] (ORconst [d] x))
// cond:
// result: (ORconst [c|d] x)
@@ -7707,7 +7710,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool {
// match: (SUB x (MOVDconst [c]))
// cond: is32Bit(-c)
// result: (ADDconst [-c] x)
@@ -7728,7 +7731,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XOR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool {
// match: (XOR (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
@@ -7907,7 +7910,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool {
// match: (XORconst [c] (XORconst [d] x))
// cond:
// result: (XORconst [c^d] x)
@@ -7939,7 +7942,7 @@
}
return false
}
-func rewriteValuePPC64_OpRound32F(v *Value) bool {
+func rewriteValuePPC64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: (LoweredRound32F x)
@@ -7950,7 +7953,7 @@
return true
}
}
-func rewriteValuePPC64_OpRound64F(v *Value) bool {
+func rewriteValuePPC64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: (LoweredRound64F x)
@@ -7961,7 +7964,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -7990,7 +7993,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8059,7 +8062,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8142,7 +8145,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8171,7 +8174,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8200,7 +8203,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8269,7 +8272,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8356,7 +8359,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8385,7 +8388,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8412,7 +8415,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8475,7 +8478,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8552,7 +8555,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8579,7 +8582,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8606,7 +8609,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8669,7 +8672,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8748,7 +8751,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8775,7 +8778,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8802,7 +8805,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8865,7 +8868,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8942,7 +8945,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8969,7 +8972,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -8996,7 +8999,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9059,7 +9062,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9138,7 +9141,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9165,7 +9168,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9194,7 +9197,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9263,7 +9266,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9346,7 +9349,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9375,7 +9378,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9404,7 +9407,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9473,7 +9476,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9560,7 +9563,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -9589,7 +9592,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
@@ -9600,7 +9603,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
@@ -9611,7 +9614,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
@@ -9622,7 +9625,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
@@ -9633,7 +9636,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
@@ -9644,7 +9647,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
@@ -9655,7 +9658,7 @@
return true
}
}
-func rewriteValuePPC64_OpSlicemask(v *Value) bool {
+func rewriteValuePPC64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -9672,7 +9675,7 @@
return true
}
}
-func rewriteValuePPC64_OpSqrt(v *Value) bool {
+func rewriteValuePPC64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRT x)
@@ -9683,7 +9686,7 @@
return true
}
}
-func rewriteValuePPC64_OpStaticCall(v *Value) bool {
+func rewriteValuePPC64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -9698,7 +9701,7 @@
return true
}
}
-func rewriteValuePPC64_OpStore(v *Value) bool {
+func rewriteValuePPC64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
@@ -9820,7 +9823,7 @@
}
return false
}
-func rewriteValuePPC64_OpSub16(v *Value) bool {
+func rewriteValuePPC64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
@@ -9833,7 +9836,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub32(v *Value) bool {
+func rewriteValuePPC64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
@@ -9846,7 +9849,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub32F(v *Value) bool {
+func rewriteValuePPC64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
@@ -9859,7 +9862,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub64(v *Value) bool {
+func rewriteValuePPC64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
@@ -9872,7 +9875,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub64F(v *Value) bool {
+func rewriteValuePPC64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUB x y)
@@ -9885,7 +9888,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub8(v *Value) bool {
+func rewriteValuePPC64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
@@ -9898,7 +9901,7 @@
return true
}
}
-func rewriteValuePPC64_OpSubPtr(v *Value) bool {
+func rewriteValuePPC64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
@@ -9911,7 +9914,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc16to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: (MOVBreg x)
@@ -9922,7 +9925,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: (MOVHreg x)
@@ -9933,7 +9936,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: (MOVBreg x)
@@ -9944,7 +9947,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: (MOVHreg x)
@@ -9955,7 +9958,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to32(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: (MOVWreg x)
@@ -9966,7 +9969,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: (MOVBreg x)
@@ -9977,7 +9980,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor16(v *Value) bool {
+func rewriteValuePPC64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
@@ -9990,7 +9993,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor32(v *Value) bool {
+func rewriteValuePPC64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
@@ -10003,7 +10006,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor64(v *Value) bool {
+func rewriteValuePPC64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
@@ -10016,7 +10019,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor8(v *Value) bool {
+func rewriteValuePPC64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
@@ -10029,7 +10032,7 @@
return true
}
}
-func rewriteValuePPC64_OpZero(v *Value) bool {
+func rewriteValuePPC64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zero [0] _ mem)
@@ -10196,6 +10199,11 @@
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuePPC64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Zero [16] destptr mem)
// cond:
// result: (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))
@@ -10384,7 +10392,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHZreg x)
@@ -10395,7 +10403,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHZreg x)
@@ -10406,7 +10414,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWZreg x)
@@ -10417,7 +10425,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBZreg x)
@@ -10428,7 +10436,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBZreg x)
@@ -10439,7 +10447,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index 6946e54..d8e8bd7 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -14,713 +14,713 @@
func rewriteValueS390X(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueS390X_OpAdd16(v)
+ return rewriteValueS390X_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueS390X_OpAdd32(v)
+ return rewriteValueS390X_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueS390X_OpAdd32F(v)
+ return rewriteValueS390X_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueS390X_OpAdd64(v)
+ return rewriteValueS390X_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueS390X_OpAdd64F(v)
+ return rewriteValueS390X_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueS390X_OpAdd8(v)
+ return rewriteValueS390X_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueS390X_OpAddPtr(v)
+ return rewriteValueS390X_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueS390X_OpAddr(v)
+ return rewriteValueS390X_OpAddr_0(v)
case OpAnd16:
- return rewriteValueS390X_OpAnd16(v)
+ return rewriteValueS390X_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueS390X_OpAnd32(v)
+ return rewriteValueS390X_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueS390X_OpAnd64(v)
+ return rewriteValueS390X_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueS390X_OpAnd8(v)
+ return rewriteValueS390X_OpAnd8_0(v)
case OpAndB:
- return rewriteValueS390X_OpAndB(v)
+ return rewriteValueS390X_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueS390X_OpAtomicAdd32(v)
+ return rewriteValueS390X_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueS390X_OpAtomicAdd64(v)
+ return rewriteValueS390X_OpAtomicAdd64_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueS390X_OpAtomicCompareAndSwap32(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueS390X_OpAtomicCompareAndSwap64(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueS390X_OpAtomicExchange32(v)
+ return rewriteValueS390X_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueS390X_OpAtomicExchange64(v)
+ return rewriteValueS390X_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueS390X_OpAtomicLoad32(v)
+ return rewriteValueS390X_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueS390X_OpAtomicLoad64(v)
+ return rewriteValueS390X_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueS390X_OpAtomicLoadPtr(v)
+ return rewriteValueS390X_OpAtomicLoadPtr_0(v)
case OpAtomicStore32:
- return rewriteValueS390X_OpAtomicStore32(v)
+ return rewriteValueS390X_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueS390X_OpAtomicStore64(v)
+ return rewriteValueS390X_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueS390X_OpAtomicStorePtrNoWB(v)
+ return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueS390X_OpAvg64u(v)
+ return rewriteValueS390X_OpAvg64u_0(v)
case OpBitLen64:
- return rewriteValueS390X_OpBitLen64(v)
+ return rewriteValueS390X_OpBitLen64_0(v)
case OpBswap32:
- return rewriteValueS390X_OpBswap32(v)
+ return rewriteValueS390X_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueS390X_OpBswap64(v)
+ return rewriteValueS390X_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueS390X_OpClosureCall(v)
+ return rewriteValueS390X_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueS390X_OpCom16(v)
+ return rewriteValueS390X_OpCom16_0(v)
case OpCom32:
- return rewriteValueS390X_OpCom32(v)
+ return rewriteValueS390X_OpCom32_0(v)
case OpCom64:
- return rewriteValueS390X_OpCom64(v)
+ return rewriteValueS390X_OpCom64_0(v)
case OpCom8:
- return rewriteValueS390X_OpCom8(v)
+ return rewriteValueS390X_OpCom8_0(v)
case OpConst16:
- return rewriteValueS390X_OpConst16(v)
+ return rewriteValueS390X_OpConst16_0(v)
case OpConst32:
- return rewriteValueS390X_OpConst32(v)
+ return rewriteValueS390X_OpConst32_0(v)
case OpConst32F:
- return rewriteValueS390X_OpConst32F(v)
+ return rewriteValueS390X_OpConst32F_0(v)
case OpConst64:
- return rewriteValueS390X_OpConst64(v)
+ return rewriteValueS390X_OpConst64_0(v)
case OpConst64F:
- return rewriteValueS390X_OpConst64F(v)
+ return rewriteValueS390X_OpConst64F_0(v)
case OpConst8:
- return rewriteValueS390X_OpConst8(v)
+ return rewriteValueS390X_OpConst8_0(v)
case OpConstBool:
- return rewriteValueS390X_OpConstBool(v)
+ return rewriteValueS390X_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueS390X_OpConstNil(v)
+ return rewriteValueS390X_OpConstNil_0(v)
case OpConvert:
- return rewriteValueS390X_OpConvert(v)
+ return rewriteValueS390X_OpConvert_0(v)
case OpCtz32:
- return rewriteValueS390X_OpCtz32(v)
+ return rewriteValueS390X_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueS390X_OpCtz64(v)
+ return rewriteValueS390X_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueS390X_OpCvt32Fto32(v)
+ return rewriteValueS390X_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueS390X_OpCvt32Fto64(v)
+ return rewriteValueS390X_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueS390X_OpCvt32Fto64F(v)
+ return rewriteValueS390X_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueS390X_OpCvt32to32F(v)
+ return rewriteValueS390X_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueS390X_OpCvt32to64F(v)
+ return rewriteValueS390X_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueS390X_OpCvt64Fto32(v)
+ return rewriteValueS390X_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueS390X_OpCvt64Fto32F(v)
+ return rewriteValueS390X_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueS390X_OpCvt64Fto64(v)
+ return rewriteValueS390X_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueS390X_OpCvt64to32F(v)
+ return rewriteValueS390X_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueS390X_OpCvt64to64F(v)
+ return rewriteValueS390X_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueS390X_OpDiv16(v)
+ return rewriteValueS390X_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueS390X_OpDiv16u(v)
+ return rewriteValueS390X_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueS390X_OpDiv32(v)
+ return rewriteValueS390X_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueS390X_OpDiv32F(v)
+ return rewriteValueS390X_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueS390X_OpDiv32u(v)
+ return rewriteValueS390X_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueS390X_OpDiv64(v)
+ return rewriteValueS390X_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueS390X_OpDiv64F(v)
+ return rewriteValueS390X_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueS390X_OpDiv64u(v)
+ return rewriteValueS390X_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueS390X_OpDiv8(v)
+ return rewriteValueS390X_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueS390X_OpDiv8u(v)
+ return rewriteValueS390X_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueS390X_OpEq16(v)
+ return rewriteValueS390X_OpEq16_0(v)
case OpEq32:
- return rewriteValueS390X_OpEq32(v)
+ return rewriteValueS390X_OpEq32_0(v)
case OpEq32F:
- return rewriteValueS390X_OpEq32F(v)
+ return rewriteValueS390X_OpEq32F_0(v)
case OpEq64:
- return rewriteValueS390X_OpEq64(v)
+ return rewriteValueS390X_OpEq64_0(v)
case OpEq64F:
- return rewriteValueS390X_OpEq64F(v)
+ return rewriteValueS390X_OpEq64F_0(v)
case OpEq8:
- return rewriteValueS390X_OpEq8(v)
+ return rewriteValueS390X_OpEq8_0(v)
case OpEqB:
- return rewriteValueS390X_OpEqB(v)
+ return rewriteValueS390X_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueS390X_OpEqPtr(v)
+ return rewriteValueS390X_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueS390X_OpGeq16(v)
+ return rewriteValueS390X_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueS390X_OpGeq16U(v)
+ return rewriteValueS390X_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueS390X_OpGeq32(v)
+ return rewriteValueS390X_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueS390X_OpGeq32F(v)
+ return rewriteValueS390X_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueS390X_OpGeq32U(v)
+ return rewriteValueS390X_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueS390X_OpGeq64(v)
+ return rewriteValueS390X_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueS390X_OpGeq64F(v)
+ return rewriteValueS390X_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueS390X_OpGeq64U(v)
+ return rewriteValueS390X_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueS390X_OpGeq8(v)
+ return rewriteValueS390X_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueS390X_OpGeq8U(v)
+ return rewriteValueS390X_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueS390X_OpGetClosurePtr(v)
+ return rewriteValueS390X_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValueS390X_OpGetG(v)
+ return rewriteValueS390X_OpGetG_0(v)
case OpGreater16:
- return rewriteValueS390X_OpGreater16(v)
+ return rewriteValueS390X_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueS390X_OpGreater16U(v)
+ return rewriteValueS390X_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueS390X_OpGreater32(v)
+ return rewriteValueS390X_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueS390X_OpGreater32F(v)
+ return rewriteValueS390X_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueS390X_OpGreater32U(v)
+ return rewriteValueS390X_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueS390X_OpGreater64(v)
+ return rewriteValueS390X_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueS390X_OpGreater64F(v)
+ return rewriteValueS390X_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueS390X_OpGreater64U(v)
+ return rewriteValueS390X_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueS390X_OpGreater8(v)
+ return rewriteValueS390X_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueS390X_OpGreater8U(v)
+ return rewriteValueS390X_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueS390X_OpHmul32(v)
+ return rewriteValueS390X_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueS390X_OpHmul32u(v)
+ return rewriteValueS390X_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueS390X_OpHmul64(v)
+ return rewriteValueS390X_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueS390X_OpHmul64u(v)
+ return rewriteValueS390X_OpHmul64u_0(v)
case OpITab:
- return rewriteValueS390X_OpITab(v)
+ return rewriteValueS390X_OpITab_0(v)
case OpInterCall:
- return rewriteValueS390X_OpInterCall(v)
+ return rewriteValueS390X_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueS390X_OpIsInBounds(v)
+ return rewriteValueS390X_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueS390X_OpIsNonNil(v)
+ return rewriteValueS390X_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueS390X_OpIsSliceInBounds(v)
+ return rewriteValueS390X_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueS390X_OpLeq16(v)
+ return rewriteValueS390X_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueS390X_OpLeq16U(v)
+ return rewriteValueS390X_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueS390X_OpLeq32(v)
+ return rewriteValueS390X_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueS390X_OpLeq32F(v)
+ return rewriteValueS390X_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueS390X_OpLeq32U(v)
+ return rewriteValueS390X_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueS390X_OpLeq64(v)
+ return rewriteValueS390X_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueS390X_OpLeq64F(v)
+ return rewriteValueS390X_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueS390X_OpLeq64U(v)
+ return rewriteValueS390X_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueS390X_OpLeq8(v)
+ return rewriteValueS390X_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueS390X_OpLeq8U(v)
+ return rewriteValueS390X_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueS390X_OpLess16(v)
+ return rewriteValueS390X_OpLess16_0(v)
case OpLess16U:
- return rewriteValueS390X_OpLess16U(v)
+ return rewriteValueS390X_OpLess16U_0(v)
case OpLess32:
- return rewriteValueS390X_OpLess32(v)
+ return rewriteValueS390X_OpLess32_0(v)
case OpLess32F:
- return rewriteValueS390X_OpLess32F(v)
+ return rewriteValueS390X_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueS390X_OpLess32U(v)
+ return rewriteValueS390X_OpLess32U_0(v)
case OpLess64:
- return rewriteValueS390X_OpLess64(v)
+ return rewriteValueS390X_OpLess64_0(v)
case OpLess64F:
- return rewriteValueS390X_OpLess64F(v)
+ return rewriteValueS390X_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueS390X_OpLess64U(v)
+ return rewriteValueS390X_OpLess64U_0(v)
case OpLess8:
- return rewriteValueS390X_OpLess8(v)
+ return rewriteValueS390X_OpLess8_0(v)
case OpLess8U:
- return rewriteValueS390X_OpLess8U(v)
+ return rewriteValueS390X_OpLess8U_0(v)
case OpLoad:
- return rewriteValueS390X_OpLoad(v)
+ return rewriteValueS390X_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueS390X_OpLsh16x16(v)
+ return rewriteValueS390X_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueS390X_OpLsh16x32(v)
+ return rewriteValueS390X_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueS390X_OpLsh16x64(v)
+ return rewriteValueS390X_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueS390X_OpLsh16x8(v)
+ return rewriteValueS390X_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueS390X_OpLsh32x16(v)
+ return rewriteValueS390X_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueS390X_OpLsh32x32(v)
+ return rewriteValueS390X_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueS390X_OpLsh32x64(v)
+ return rewriteValueS390X_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueS390X_OpLsh32x8(v)
+ return rewriteValueS390X_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueS390X_OpLsh64x16(v)
+ return rewriteValueS390X_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueS390X_OpLsh64x32(v)
+ return rewriteValueS390X_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueS390X_OpLsh64x64(v)
+ return rewriteValueS390X_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueS390X_OpLsh64x8(v)
+ return rewriteValueS390X_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueS390X_OpLsh8x16(v)
+ return rewriteValueS390X_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueS390X_OpLsh8x32(v)
+ return rewriteValueS390X_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueS390X_OpLsh8x64(v)
+ return rewriteValueS390X_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueS390X_OpLsh8x8(v)
+ return rewriteValueS390X_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueS390X_OpMod16(v)
+ return rewriteValueS390X_OpMod16_0(v)
case OpMod16u:
- return rewriteValueS390X_OpMod16u(v)
+ return rewriteValueS390X_OpMod16u_0(v)
case OpMod32:
- return rewriteValueS390X_OpMod32(v)
+ return rewriteValueS390X_OpMod32_0(v)
case OpMod32u:
- return rewriteValueS390X_OpMod32u(v)
+ return rewriteValueS390X_OpMod32u_0(v)
case OpMod64:
- return rewriteValueS390X_OpMod64(v)
+ return rewriteValueS390X_OpMod64_0(v)
case OpMod64u:
- return rewriteValueS390X_OpMod64u(v)
+ return rewriteValueS390X_OpMod64u_0(v)
case OpMod8:
- return rewriteValueS390X_OpMod8(v)
+ return rewriteValueS390X_OpMod8_0(v)
case OpMod8u:
- return rewriteValueS390X_OpMod8u(v)
+ return rewriteValueS390X_OpMod8u_0(v)
case OpMove:
- return rewriteValueS390X_OpMove(v)
+ return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
case OpMul16:
- return rewriteValueS390X_OpMul16(v)
+ return rewriteValueS390X_OpMul16_0(v)
case OpMul32:
- return rewriteValueS390X_OpMul32(v)
+ return rewriteValueS390X_OpMul32_0(v)
case OpMul32F:
- return rewriteValueS390X_OpMul32F(v)
+ return rewriteValueS390X_OpMul32F_0(v)
case OpMul64:
- return rewriteValueS390X_OpMul64(v)
+ return rewriteValueS390X_OpMul64_0(v)
case OpMul64F:
- return rewriteValueS390X_OpMul64F(v)
+ return rewriteValueS390X_OpMul64F_0(v)
case OpMul8:
- return rewriteValueS390X_OpMul8(v)
+ return rewriteValueS390X_OpMul8_0(v)
case OpNeg16:
- return rewriteValueS390X_OpNeg16(v)
+ return rewriteValueS390X_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueS390X_OpNeg32(v)
+ return rewriteValueS390X_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueS390X_OpNeg32F(v)
+ return rewriteValueS390X_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueS390X_OpNeg64(v)
+ return rewriteValueS390X_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueS390X_OpNeg64F(v)
+ return rewriteValueS390X_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueS390X_OpNeg8(v)
+ return rewriteValueS390X_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueS390X_OpNeq16(v)
+ return rewriteValueS390X_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueS390X_OpNeq32(v)
+ return rewriteValueS390X_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueS390X_OpNeq32F(v)
+ return rewriteValueS390X_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueS390X_OpNeq64(v)
+ return rewriteValueS390X_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueS390X_OpNeq64F(v)
+ return rewriteValueS390X_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueS390X_OpNeq8(v)
+ return rewriteValueS390X_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueS390X_OpNeqB(v)
+ return rewriteValueS390X_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueS390X_OpNeqPtr(v)
+ return rewriteValueS390X_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueS390X_OpNilCheck(v)
+ return rewriteValueS390X_OpNilCheck_0(v)
case OpNot:
- return rewriteValueS390X_OpNot(v)
+ return rewriteValueS390X_OpNot_0(v)
case OpOffPtr:
- return rewriteValueS390X_OpOffPtr(v)
+ return rewriteValueS390X_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueS390X_OpOr16(v)
+ return rewriteValueS390X_OpOr16_0(v)
case OpOr32:
- return rewriteValueS390X_OpOr32(v)
+ return rewriteValueS390X_OpOr32_0(v)
case OpOr64:
- return rewriteValueS390X_OpOr64(v)
+ return rewriteValueS390X_OpOr64_0(v)
case OpOr8:
- return rewriteValueS390X_OpOr8(v)
+ return rewriteValueS390X_OpOr8_0(v)
case OpOrB:
- return rewriteValueS390X_OpOrB(v)
+ return rewriteValueS390X_OpOrB_0(v)
case OpRound32F:
- return rewriteValueS390X_OpRound32F(v)
+ return rewriteValueS390X_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueS390X_OpRound64F(v)
+ return rewriteValueS390X_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueS390X_OpRsh16Ux16(v)
+ return rewriteValueS390X_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueS390X_OpRsh16Ux32(v)
+ return rewriteValueS390X_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueS390X_OpRsh16Ux64(v)
+ return rewriteValueS390X_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueS390X_OpRsh16Ux8(v)
+ return rewriteValueS390X_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueS390X_OpRsh16x16(v)
+ return rewriteValueS390X_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueS390X_OpRsh16x32(v)
+ return rewriteValueS390X_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueS390X_OpRsh16x64(v)
+ return rewriteValueS390X_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueS390X_OpRsh16x8(v)
+ return rewriteValueS390X_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueS390X_OpRsh32Ux16(v)
+ return rewriteValueS390X_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueS390X_OpRsh32Ux32(v)
+ return rewriteValueS390X_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueS390X_OpRsh32Ux64(v)
+ return rewriteValueS390X_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueS390X_OpRsh32Ux8(v)
+ return rewriteValueS390X_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueS390X_OpRsh32x16(v)
+ return rewriteValueS390X_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueS390X_OpRsh32x32(v)
+ return rewriteValueS390X_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueS390X_OpRsh32x64(v)
+ return rewriteValueS390X_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueS390X_OpRsh32x8(v)
+ return rewriteValueS390X_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueS390X_OpRsh64Ux16(v)
+ return rewriteValueS390X_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueS390X_OpRsh64Ux32(v)
+ return rewriteValueS390X_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueS390X_OpRsh64Ux64(v)
+ return rewriteValueS390X_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueS390X_OpRsh64Ux8(v)
+ return rewriteValueS390X_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueS390X_OpRsh64x16(v)
+ return rewriteValueS390X_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueS390X_OpRsh64x32(v)
+ return rewriteValueS390X_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueS390X_OpRsh64x64(v)
+ return rewriteValueS390X_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueS390X_OpRsh64x8(v)
+ return rewriteValueS390X_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueS390X_OpRsh8Ux16(v)
+ return rewriteValueS390X_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueS390X_OpRsh8Ux32(v)
+ return rewriteValueS390X_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueS390X_OpRsh8Ux64(v)
+ return rewriteValueS390X_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueS390X_OpRsh8Ux8(v)
+ return rewriteValueS390X_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueS390X_OpRsh8x16(v)
+ return rewriteValueS390X_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueS390X_OpRsh8x32(v)
+ return rewriteValueS390X_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueS390X_OpRsh8x64(v)
+ return rewriteValueS390X_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueS390X_OpRsh8x8(v)
+ return rewriteValueS390X_OpRsh8x8_0(v)
case OpS390XADD:
- return rewriteValueS390X_OpS390XADD(v)
+ return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
case OpS390XADDW:
- return rewriteValueS390X_OpS390XADDW(v)
+ return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
case OpS390XADDWconst:
- return rewriteValueS390X_OpS390XADDWconst(v)
+ return rewriteValueS390X_OpS390XADDWconst_0(v)
case OpS390XADDconst:
- return rewriteValueS390X_OpS390XADDconst(v)
+ return rewriteValueS390X_OpS390XADDconst_0(v)
case OpS390XAND:
- return rewriteValueS390X_OpS390XAND(v)
+ return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
case OpS390XANDW:
- return rewriteValueS390X_OpS390XANDW(v)
+ return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
case OpS390XANDWconst:
- return rewriteValueS390X_OpS390XANDWconst(v)
+ return rewriteValueS390X_OpS390XANDWconst_0(v)
case OpS390XANDconst:
- return rewriteValueS390X_OpS390XANDconst(v)
+ return rewriteValueS390X_OpS390XANDconst_0(v)
case OpS390XCMP:
- return rewriteValueS390X_OpS390XCMP(v)
+ return rewriteValueS390X_OpS390XCMP_0(v)
case OpS390XCMPU:
- return rewriteValueS390X_OpS390XCMPU(v)
+ return rewriteValueS390X_OpS390XCMPU_0(v)
case OpS390XCMPUconst:
- return rewriteValueS390X_OpS390XCMPUconst(v)
+ return rewriteValueS390X_OpS390XCMPUconst_0(v)
case OpS390XCMPW:
- return rewriteValueS390X_OpS390XCMPW(v)
+ return rewriteValueS390X_OpS390XCMPW_0(v)
case OpS390XCMPWU:
- return rewriteValueS390X_OpS390XCMPWU(v)
+ return rewriteValueS390X_OpS390XCMPWU_0(v)
case OpS390XCMPWUconst:
- return rewriteValueS390X_OpS390XCMPWUconst(v)
+ return rewriteValueS390X_OpS390XCMPWUconst_0(v)
case OpS390XCMPWconst:
- return rewriteValueS390X_OpS390XCMPWconst(v)
+ return rewriteValueS390X_OpS390XCMPWconst_0(v)
case OpS390XCMPconst:
- return rewriteValueS390X_OpS390XCMPconst(v)
+ return rewriteValueS390X_OpS390XCMPconst_0(v)
case OpS390XFADD:
- return rewriteValueS390X_OpS390XFADD(v)
+ return rewriteValueS390X_OpS390XFADD_0(v)
case OpS390XFADDS:
- return rewriteValueS390X_OpS390XFADDS(v)
+ return rewriteValueS390X_OpS390XFADDS_0(v)
case OpS390XFMOVDload:
- return rewriteValueS390X_OpS390XFMOVDload(v)
+ return rewriteValueS390X_OpS390XFMOVDload_0(v)
case OpS390XFMOVDloadidx:
- return rewriteValueS390X_OpS390XFMOVDloadidx(v)
+ return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
case OpS390XFMOVDstore:
- return rewriteValueS390X_OpS390XFMOVDstore(v)
+ return rewriteValueS390X_OpS390XFMOVDstore_0(v)
case OpS390XFMOVDstoreidx:
- return rewriteValueS390X_OpS390XFMOVDstoreidx(v)
+ return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
case OpS390XFMOVSload:
- return rewriteValueS390X_OpS390XFMOVSload(v)
+ return rewriteValueS390X_OpS390XFMOVSload_0(v)
case OpS390XFMOVSloadidx:
- return rewriteValueS390X_OpS390XFMOVSloadidx(v)
+ return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
case OpS390XFMOVSstore:
- return rewriteValueS390X_OpS390XFMOVSstore(v)
+ return rewriteValueS390X_OpS390XFMOVSstore_0(v)
case OpS390XFMOVSstoreidx:
- return rewriteValueS390X_OpS390XFMOVSstoreidx(v)
+ return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
case OpS390XFSUB:
- return rewriteValueS390X_OpS390XFSUB(v)
+ return rewriteValueS390X_OpS390XFSUB_0(v)
case OpS390XFSUBS:
- return rewriteValueS390X_OpS390XFSUBS(v)
+ return rewriteValueS390X_OpS390XFSUBS_0(v)
case OpS390XLoweredRound32F:
- return rewriteValueS390X_OpS390XLoweredRound32F(v)
+ return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
case OpS390XLoweredRound64F:
- return rewriteValueS390X_OpS390XLoweredRound64F(v)
+ return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
case OpS390XMOVBZload:
- return rewriteValueS390X_OpS390XMOVBZload(v)
+ return rewriteValueS390X_OpS390XMOVBZload_0(v)
case OpS390XMOVBZloadidx:
- return rewriteValueS390X_OpS390XMOVBZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
case OpS390XMOVBZreg:
- return rewriteValueS390X_OpS390XMOVBZreg(v)
+ return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
case OpS390XMOVBload:
- return rewriteValueS390X_OpS390XMOVBload(v)
+ return rewriteValueS390X_OpS390XMOVBload_0(v)
case OpS390XMOVBreg:
- return rewriteValueS390X_OpS390XMOVBreg(v)
+ return rewriteValueS390X_OpS390XMOVBreg_0(v)
case OpS390XMOVBstore:
- return rewriteValueS390X_OpS390XMOVBstore(v)
+ return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
case OpS390XMOVBstoreconst:
- return rewriteValueS390X_OpS390XMOVBstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
case OpS390XMOVBstoreidx:
- return rewriteValueS390X_OpS390XMOVBstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
case OpS390XMOVDEQ:
- return rewriteValueS390X_OpS390XMOVDEQ(v)
+ return rewriteValueS390X_OpS390XMOVDEQ_0(v)
case OpS390XMOVDGE:
- return rewriteValueS390X_OpS390XMOVDGE(v)
+ return rewriteValueS390X_OpS390XMOVDGE_0(v)
case OpS390XMOVDGT:
- return rewriteValueS390X_OpS390XMOVDGT(v)
+ return rewriteValueS390X_OpS390XMOVDGT_0(v)
case OpS390XMOVDLE:
- return rewriteValueS390X_OpS390XMOVDLE(v)
+ return rewriteValueS390X_OpS390XMOVDLE_0(v)
case OpS390XMOVDLT:
- return rewriteValueS390X_OpS390XMOVDLT(v)
+ return rewriteValueS390X_OpS390XMOVDLT_0(v)
case OpS390XMOVDNE:
- return rewriteValueS390X_OpS390XMOVDNE(v)
+ return rewriteValueS390X_OpS390XMOVDNE_0(v)
case OpS390XMOVDaddridx:
- return rewriteValueS390X_OpS390XMOVDaddridx(v)
+ return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
case OpS390XMOVDload:
- return rewriteValueS390X_OpS390XMOVDload(v)
+ return rewriteValueS390X_OpS390XMOVDload_0(v)
case OpS390XMOVDloadidx:
- return rewriteValueS390X_OpS390XMOVDloadidx(v)
+ return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
case OpS390XMOVDnop:
- return rewriteValueS390X_OpS390XMOVDnop(v)
+ return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
case OpS390XMOVDreg:
- return rewriteValueS390X_OpS390XMOVDreg(v)
+ return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
case OpS390XMOVDstore:
- return rewriteValueS390X_OpS390XMOVDstore(v)
+ return rewriteValueS390X_OpS390XMOVDstore_0(v)
case OpS390XMOVDstoreconst:
- return rewriteValueS390X_OpS390XMOVDstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
case OpS390XMOVDstoreidx:
- return rewriteValueS390X_OpS390XMOVDstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
case OpS390XMOVHBRstore:
- return rewriteValueS390X_OpS390XMOVHBRstore(v)
+ return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
case OpS390XMOVHBRstoreidx:
- return rewriteValueS390X_OpS390XMOVHBRstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
case OpS390XMOVHZload:
- return rewriteValueS390X_OpS390XMOVHZload(v)
+ return rewriteValueS390X_OpS390XMOVHZload_0(v)
case OpS390XMOVHZloadidx:
- return rewriteValueS390X_OpS390XMOVHZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
case OpS390XMOVHZreg:
- return rewriteValueS390X_OpS390XMOVHZreg(v)
+ return rewriteValueS390X_OpS390XMOVHZreg_0(v)
case OpS390XMOVHload:
- return rewriteValueS390X_OpS390XMOVHload(v)
+ return rewriteValueS390X_OpS390XMOVHload_0(v)
case OpS390XMOVHreg:
- return rewriteValueS390X_OpS390XMOVHreg(v)
+ return rewriteValueS390X_OpS390XMOVHreg_0(v)
case OpS390XMOVHstore:
- return rewriteValueS390X_OpS390XMOVHstore(v)
+ return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
case OpS390XMOVHstoreconst:
- return rewriteValueS390X_OpS390XMOVHstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
case OpS390XMOVHstoreidx:
- return rewriteValueS390X_OpS390XMOVHstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
case OpS390XMOVWBRstore:
- return rewriteValueS390X_OpS390XMOVWBRstore(v)
+ return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
case OpS390XMOVWBRstoreidx:
- return rewriteValueS390X_OpS390XMOVWBRstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
case OpS390XMOVWZload:
- return rewriteValueS390X_OpS390XMOVWZload(v)
+ return rewriteValueS390X_OpS390XMOVWZload_0(v)
case OpS390XMOVWZloadidx:
- return rewriteValueS390X_OpS390XMOVWZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
case OpS390XMOVWZreg:
- return rewriteValueS390X_OpS390XMOVWZreg(v)
+ return rewriteValueS390X_OpS390XMOVWZreg_0(v)
case OpS390XMOVWload:
- return rewriteValueS390X_OpS390XMOVWload(v)
+ return rewriteValueS390X_OpS390XMOVWload_0(v)
case OpS390XMOVWreg:
- return rewriteValueS390X_OpS390XMOVWreg(v)
+ return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
case OpS390XMOVWstore:
- return rewriteValueS390X_OpS390XMOVWstore(v)
+ return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
case OpS390XMOVWstoreconst:
- return rewriteValueS390X_OpS390XMOVWstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
case OpS390XMOVWstoreidx:
- return rewriteValueS390X_OpS390XMOVWstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
case OpS390XMULLD:
- return rewriteValueS390X_OpS390XMULLD(v)
+ return rewriteValueS390X_OpS390XMULLD_0(v)
case OpS390XMULLDconst:
- return rewriteValueS390X_OpS390XMULLDconst(v)
+ return rewriteValueS390X_OpS390XMULLDconst_0(v)
case OpS390XMULLW:
- return rewriteValueS390X_OpS390XMULLW(v)
+ return rewriteValueS390X_OpS390XMULLW_0(v)
case OpS390XMULLWconst:
- return rewriteValueS390X_OpS390XMULLWconst(v)
+ return rewriteValueS390X_OpS390XMULLWconst_0(v)
case OpS390XNEG:
- return rewriteValueS390X_OpS390XNEG(v)
+ return rewriteValueS390X_OpS390XNEG_0(v)
case OpS390XNEGW:
- return rewriteValueS390X_OpS390XNEGW(v)
+ return rewriteValueS390X_OpS390XNEGW_0(v)
case OpS390XNOT:
- return rewriteValueS390X_OpS390XNOT(v)
+ return rewriteValueS390X_OpS390XNOT_0(v)
case OpS390XNOTW:
- return rewriteValueS390X_OpS390XNOTW(v)
+ return rewriteValueS390X_OpS390XNOTW_0(v)
case OpS390XOR:
- return rewriteValueS390X_OpS390XOR(v)
+ return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
case OpS390XORW:
- return rewriteValueS390X_OpS390XORW(v)
+ return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
case OpS390XORWconst:
- return rewriteValueS390X_OpS390XORWconst(v)
+ return rewriteValueS390X_OpS390XORWconst_0(v)
case OpS390XORconst:
- return rewriteValueS390X_OpS390XORconst(v)
+ return rewriteValueS390X_OpS390XORconst_0(v)
case OpS390XSLD:
- return rewriteValueS390X_OpS390XSLD(v)
+ return rewriteValueS390X_OpS390XSLD_0(v)
case OpS390XSLW:
- return rewriteValueS390X_OpS390XSLW(v)
+ return rewriteValueS390X_OpS390XSLW_0(v)
case OpS390XSRAD:
- return rewriteValueS390X_OpS390XSRAD(v)
+ return rewriteValueS390X_OpS390XSRAD_0(v)
case OpS390XSRADconst:
- return rewriteValueS390X_OpS390XSRADconst(v)
+ return rewriteValueS390X_OpS390XSRADconst_0(v)
case OpS390XSRAW:
- return rewriteValueS390X_OpS390XSRAW(v)
+ return rewriteValueS390X_OpS390XSRAW_0(v)
case OpS390XSRAWconst:
- return rewriteValueS390X_OpS390XSRAWconst(v)
+ return rewriteValueS390X_OpS390XSRAWconst_0(v)
case OpS390XSRD:
- return rewriteValueS390X_OpS390XSRD(v)
+ return rewriteValueS390X_OpS390XSRD_0(v)
case OpS390XSRW:
- return rewriteValueS390X_OpS390XSRW(v)
+ return rewriteValueS390X_OpS390XSRW_0(v)
case OpS390XSTM2:
- return rewriteValueS390X_OpS390XSTM2(v)
+ return rewriteValueS390X_OpS390XSTM2_0(v)
case OpS390XSTMG2:
- return rewriteValueS390X_OpS390XSTMG2(v)
+ return rewriteValueS390X_OpS390XSTMG2_0(v)
case OpS390XSUB:
- return rewriteValueS390X_OpS390XSUB(v)
+ return rewriteValueS390X_OpS390XSUB_0(v)
case OpS390XSUBEWcarrymask:
- return rewriteValueS390X_OpS390XSUBEWcarrymask(v)
+ return rewriteValueS390X_OpS390XSUBEWcarrymask_0(v)
case OpS390XSUBEcarrymask:
- return rewriteValueS390X_OpS390XSUBEcarrymask(v)
+ return rewriteValueS390X_OpS390XSUBEcarrymask_0(v)
case OpS390XSUBW:
- return rewriteValueS390X_OpS390XSUBW(v)
+ return rewriteValueS390X_OpS390XSUBW_0(v)
case OpS390XSUBWconst:
- return rewriteValueS390X_OpS390XSUBWconst(v)
+ return rewriteValueS390X_OpS390XSUBWconst_0(v)
case OpS390XSUBconst:
- return rewriteValueS390X_OpS390XSUBconst(v)
+ return rewriteValueS390X_OpS390XSUBconst_0(v)
case OpS390XXOR:
- return rewriteValueS390X_OpS390XXOR(v)
+ return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
case OpS390XXORW:
- return rewriteValueS390X_OpS390XXORW(v)
+ return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
case OpS390XXORWconst:
- return rewriteValueS390X_OpS390XXORWconst(v)
+ return rewriteValueS390X_OpS390XXORWconst_0(v)
case OpS390XXORconst:
- return rewriteValueS390X_OpS390XXORconst(v)
+ return rewriteValueS390X_OpS390XXORconst_0(v)
case OpSelect0:
- return rewriteValueS390X_OpSelect0(v)
+ return rewriteValueS390X_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueS390X_OpSelect1(v)
+ return rewriteValueS390X_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueS390X_OpSignExt16to32(v)
+ return rewriteValueS390X_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueS390X_OpSignExt16to64(v)
+ return rewriteValueS390X_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueS390X_OpSignExt32to64(v)
+ return rewriteValueS390X_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueS390X_OpSignExt8to16(v)
+ return rewriteValueS390X_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueS390X_OpSignExt8to32(v)
+ return rewriteValueS390X_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueS390X_OpSignExt8to64(v)
+ return rewriteValueS390X_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueS390X_OpSlicemask(v)
+ return rewriteValueS390X_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueS390X_OpSqrt(v)
+ return rewriteValueS390X_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueS390X_OpStaticCall(v)
+ return rewriteValueS390X_OpStaticCall_0(v)
case OpStore:
- return rewriteValueS390X_OpStore(v)
+ return rewriteValueS390X_OpStore_0(v)
case OpSub16:
- return rewriteValueS390X_OpSub16(v)
+ return rewriteValueS390X_OpSub16_0(v)
case OpSub32:
- return rewriteValueS390X_OpSub32(v)
+ return rewriteValueS390X_OpSub32_0(v)
case OpSub32F:
- return rewriteValueS390X_OpSub32F(v)
+ return rewriteValueS390X_OpSub32F_0(v)
case OpSub64:
- return rewriteValueS390X_OpSub64(v)
+ return rewriteValueS390X_OpSub64_0(v)
case OpSub64F:
- return rewriteValueS390X_OpSub64F(v)
+ return rewriteValueS390X_OpSub64F_0(v)
case OpSub8:
- return rewriteValueS390X_OpSub8(v)
+ return rewriteValueS390X_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueS390X_OpSubPtr(v)
+ return rewriteValueS390X_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueS390X_OpTrunc16to8(v)
+ return rewriteValueS390X_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueS390X_OpTrunc32to16(v)
+ return rewriteValueS390X_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueS390X_OpTrunc32to8(v)
+ return rewriteValueS390X_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueS390X_OpTrunc64to16(v)
+ return rewriteValueS390X_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueS390X_OpTrunc64to32(v)
+ return rewriteValueS390X_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueS390X_OpTrunc64to8(v)
+ return rewriteValueS390X_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueS390X_OpXor16(v)
+ return rewriteValueS390X_OpXor16_0(v)
case OpXor32:
- return rewriteValueS390X_OpXor32(v)
+ return rewriteValueS390X_OpXor32_0(v)
case OpXor64:
- return rewriteValueS390X_OpXor64(v)
+ return rewriteValueS390X_OpXor64_0(v)
case OpXor8:
- return rewriteValueS390X_OpXor8(v)
+ return rewriteValueS390X_OpXor8_0(v)
case OpZero:
- return rewriteValueS390X_OpZero(v)
+ return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueS390X_OpZeroExt16to32(v)
+ return rewriteValueS390X_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueS390X_OpZeroExt16to64(v)
+ return rewriteValueS390X_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueS390X_OpZeroExt32to64(v)
+ return rewriteValueS390X_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueS390X_OpZeroExt8to16(v)
+ return rewriteValueS390X_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueS390X_OpZeroExt8to32(v)
+ return rewriteValueS390X_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueS390X_OpZeroExt8to64(v)
+ return rewriteValueS390X_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueS390X_OpAdd16(v *Value) bool {
+func rewriteValueS390X_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDW x y)
@@ -733,7 +733,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd32(v *Value) bool {
+func rewriteValueS390X_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDW x y)
@@ -746,7 +746,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd32F(v *Value) bool {
+func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
@@ -759,7 +759,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd64(v *Value) bool {
+func rewriteValueS390X_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
@@ -772,7 +772,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd64F(v *Value) bool {
+func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADD x y)
@@ -785,7 +785,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd8(v *Value) bool {
+func rewriteValueS390X_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDW x y)
@@ -798,7 +798,7 @@
return true
}
}
-func rewriteValueS390X_OpAddPtr(v *Value) bool {
+func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
@@ -811,7 +811,7 @@
return true
}
}
-func rewriteValueS390X_OpAddr(v *Value) bool {
+func rewriteValueS390X_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
@@ -824,7 +824,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd16(v *Value) bool {
+func rewriteValueS390X_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDW x y)
@@ -837,7 +837,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd32(v *Value) bool {
+func rewriteValueS390X_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDW x y)
@@ -850,7 +850,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd64(v *Value) bool {
+func rewriteValueS390X_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
@@ -863,7 +863,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd8(v *Value) bool {
+func rewriteValueS390X_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDW x y)
@@ -876,7 +876,7 @@
return true
}
}
-func rewriteValueS390X_OpAndB(v *Value) bool {
+func rewriteValueS390X_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDW x y)
@@ -889,7 +889,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd32(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -911,7 +911,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd64(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -933,7 +933,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
@@ -950,7 +950,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
@@ -967,7 +967,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange32(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
@@ -982,7 +982,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange64(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
@@ -997,7 +997,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad32(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (MOVWZatomicload ptr mem)
@@ -1010,7 +1010,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad64(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (MOVDatomicload ptr mem)
@@ -1023,7 +1023,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (MOVDatomicload ptr mem)
@@ -1036,7 +1036,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore32(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (MOVWatomicstore ptr val mem)
@@ -1051,7 +1051,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore64(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (MOVDatomicstore ptr val mem)
@@ -1066,7 +1066,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (MOVDatomicstore ptr val mem)
@@ -1081,7 +1081,7 @@
return true
}
}
-func rewriteValueS390X_OpAvg64u(v *Value) bool {
+func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
@@ -1103,7 +1103,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen64(v *Value) bool {
+func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1123,7 +1123,7 @@
return true
}
}
-func rewriteValueS390X_OpBswap32(v *Value) bool {
+func rewriteValueS390X_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (MOVWBR x)
@@ -1134,7 +1134,7 @@
return true
}
}
-func rewriteValueS390X_OpBswap64(v *Value) bool {
+func rewriteValueS390X_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (MOVDBR x)
@@ -1145,7 +1145,7 @@
return true
}
}
-func rewriteValueS390X_OpClosureCall(v *Value) bool {
+func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
@@ -1162,7 +1162,7 @@
return true
}
}
-func rewriteValueS390X_OpCom16(v *Value) bool {
+func rewriteValueS390X_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTW x)
@@ -1173,7 +1173,7 @@
return true
}
}
-func rewriteValueS390X_OpCom32(v *Value) bool {
+func rewriteValueS390X_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTW x)
@@ -1184,7 +1184,7 @@
return true
}
}
-func rewriteValueS390X_OpCom64(v *Value) bool {
+func rewriteValueS390X_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOT x)
@@ -1195,7 +1195,7 @@
return true
}
}
-func rewriteValueS390X_OpCom8(v *Value) bool {
+func rewriteValueS390X_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTW x)
@@ -1206,7 +1206,7 @@
return true
}
}
-func rewriteValueS390X_OpConst16(v *Value) bool {
+func rewriteValueS390X_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
@@ -1217,7 +1217,7 @@
return true
}
}
-func rewriteValueS390X_OpConst32(v *Value) bool {
+func rewriteValueS390X_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
@@ -1228,7 +1228,7 @@
return true
}
}
-func rewriteValueS390X_OpConst32F(v *Value) bool {
+func rewriteValueS390X_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
@@ -1239,7 +1239,7 @@
return true
}
}
-func rewriteValueS390X_OpConst64(v *Value) bool {
+func rewriteValueS390X_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
@@ -1250,7 +1250,7 @@
return true
}
}
-func rewriteValueS390X_OpConst64F(v *Value) bool {
+func rewriteValueS390X_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
@@ -1261,7 +1261,7 @@
return true
}
}
-func rewriteValueS390X_OpConst8(v *Value) bool {
+func rewriteValueS390X_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
@@ -1272,7 +1272,7 @@
return true
}
}
-func rewriteValueS390X_OpConstBool(v *Value) bool {
+func rewriteValueS390X_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
@@ -1283,7 +1283,7 @@
return true
}
}
-func rewriteValueS390X_OpConstNil(v *Value) bool {
+func rewriteValueS390X_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
@@ -1293,7 +1293,7 @@
return true
}
}
-func rewriteValueS390X_OpConvert(v *Value) bool {
+func rewriteValueS390X_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVDconvert <t> x mem)
@@ -1308,7 +1308,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz32(v *Value) bool {
+func rewriteValueS390X_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1339,7 +1339,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz64(v *Value) bool {
+func rewriteValueS390X_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1368,7 +1368,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CFEBRA x)
@@ -1379,7 +1379,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (CGEBRA x)
@@ -1390,7 +1390,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (LDEBR x)
@@ -1401,7 +1401,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CEFBRA x)
@@ -1412,7 +1412,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CDFBRA x)
@@ -1423,7 +1423,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CFDBRA x)
@@ -1434,7 +1434,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (LEDBR x)
@@ -1445,7 +1445,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (CGDBRA x)
@@ -1456,7 +1456,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (CEGBRA x)
@@ -1467,7 +1467,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (CDGBRA x)
@@ -1478,7 +1478,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16(v *Value) bool {
+func rewriteValueS390X_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1499,7 +1499,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16u(v *Value) bool {
+func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1520,7 +1520,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32(v *Value) bool {
+func rewriteValueS390X_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1539,7 +1539,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32F(v *Value) bool {
+func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
@@ -1552,7 +1552,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32u(v *Value) bool {
+func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1571,7 +1571,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64(v *Value) bool {
+func rewriteValueS390X_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIVD x y)
@@ -1584,7 +1584,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64F(v *Value) bool {
+func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIV x y)
@@ -1597,7 +1597,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64u(v *Value) bool {
+func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (DIVDU x y)
@@ -1610,7 +1610,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8(v *Value) bool {
+func rewriteValueS390X_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1631,7 +1631,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8u(v *Value) bool {
+func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1652,7 +1652,7 @@
return true
}
}
-func rewriteValueS390X_OpEq16(v *Value) bool {
+func rewriteValueS390X_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1681,7 +1681,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32(v *Value) bool {
+func rewriteValueS390X_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1706,7 +1706,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32F(v *Value) bool {
+func rewriteValueS390X_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1731,7 +1731,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64(v *Value) bool {
+func rewriteValueS390X_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1756,7 +1756,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64F(v *Value) bool {
+func rewriteValueS390X_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1781,7 +1781,7 @@
return true
}
}
-func rewriteValueS390X_OpEq8(v *Value) bool {
+func rewriteValueS390X_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1810,7 +1810,7 @@
return true
}
}
-func rewriteValueS390X_OpEqB(v *Value) bool {
+func rewriteValueS390X_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1839,7 +1839,7 @@
return true
}
}
-func rewriteValueS390X_OpEqPtr(v *Value) bool {
+func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1864,7 +1864,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq16(v *Value) bool {
+func rewriteValueS390X_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1893,7 +1893,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq16U(v *Value) bool {
+func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1922,7 +1922,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32(v *Value) bool {
+func rewriteValueS390X_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1947,7 +1947,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32F(v *Value) bool {
+func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1972,7 +1972,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32U(v *Value) bool {
+func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -1997,7 +1997,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64(v *Value) bool {
+func rewriteValueS390X_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2022,7 +2022,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64F(v *Value) bool {
+func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2047,7 +2047,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64U(v *Value) bool {
+func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2072,7 +2072,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq8(v *Value) bool {
+func rewriteValueS390X_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2101,7 +2101,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq8U(v *Value) bool {
+func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2130,7 +2130,7 @@
return true
}
}
-func rewriteValueS390X_OpGetClosurePtr(v *Value) bool {
+func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
@@ -2139,7 +2139,7 @@
return true
}
}
-func rewriteValueS390X_OpGetG(v *Value) bool {
+func rewriteValueS390X_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
@@ -2150,7 +2150,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater16(v *Value) bool {
+func rewriteValueS390X_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2179,7 +2179,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater16U(v *Value) bool {
+func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2208,7 +2208,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32(v *Value) bool {
+func rewriteValueS390X_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2233,7 +2233,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32F(v *Value) bool {
+func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2258,7 +2258,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32U(v *Value) bool {
+func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2283,7 +2283,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64(v *Value) bool {
+func rewriteValueS390X_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2308,7 +2308,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64F(v *Value) bool {
+func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2333,7 +2333,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64U(v *Value) bool {
+func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2358,7 +2358,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater8(v *Value) bool {
+func rewriteValueS390X_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2387,7 +2387,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater8U(v *Value) bool {
+func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2416,7 +2416,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32(v *Value) bool {
+func rewriteValueS390X_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2440,7 +2440,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32u(v *Value) bool {
+func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2464,7 +2464,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul64(v *Value) bool {
+func rewriteValueS390X_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULHD x y)
@@ -2477,7 +2477,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul64u(v *Value) bool {
+func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (MULHDU x y)
@@ -2490,7 +2490,7 @@
return true
}
}
-func rewriteValueS390X_OpITab(v *Value) bool {
+func rewriteValueS390X_OpITab_0(v *Value) bool {
// match: (ITab (Load ptr mem))
// cond:
// result: (MOVDload ptr mem)
@@ -2508,7 +2508,7 @@
}
return false
}
-func rewriteValueS390X_OpInterCall(v *Value) bool {
+func rewriteValueS390X_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
@@ -2523,7 +2523,7 @@
return true
}
}
-func rewriteValueS390X_OpIsInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2548,7 +2548,7 @@
return true
}
}
-func rewriteValueS390X_OpIsNonNil(v *Value) bool {
+func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2572,7 +2572,7 @@
return true
}
}
-func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2597,7 +2597,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16(v *Value) bool {
+func rewriteValueS390X_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2626,7 +2626,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16U(v *Value) bool {
+func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2655,7 +2655,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32(v *Value) bool {
+func rewriteValueS390X_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2680,7 +2680,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32F(v *Value) bool {
+func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2705,7 +2705,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32U(v *Value) bool {
+func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2730,7 +2730,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64(v *Value) bool {
+func rewriteValueS390X_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2755,7 +2755,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64F(v *Value) bool {
+func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2780,7 +2780,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64U(v *Value) bool {
+func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2805,7 +2805,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8(v *Value) bool {
+func rewriteValueS390X_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2834,7 +2834,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8U(v *Value) bool {
+func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2863,7 +2863,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16(v *Value) bool {
+func rewriteValueS390X_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2892,7 +2892,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16U(v *Value) bool {
+func rewriteValueS390X_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2921,7 +2921,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32(v *Value) bool {
+func rewriteValueS390X_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2946,7 +2946,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32F(v *Value) bool {
+func rewriteValueS390X_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2971,7 +2971,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32U(v *Value) bool {
+func rewriteValueS390X_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -2996,7 +2996,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64(v *Value) bool {
+func rewriteValueS390X_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3021,7 +3021,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64F(v *Value) bool {
+func rewriteValueS390X_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3046,7 +3046,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64U(v *Value) bool {
+func rewriteValueS390X_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3071,7 +3071,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8(v *Value) bool {
+func rewriteValueS390X_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3100,7 +3100,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8U(v *Value) bool {
+func rewriteValueS390X_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3129,7 +3129,7 @@
return true
}
}
-func rewriteValueS390X_OpLoad(v *Value) bool {
+func rewriteValueS390X_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: (is64BitInt(t) || isPtr(t))
// result: (MOVDload ptr mem)
@@ -3267,7 +3267,7 @@
}
return false
}
-func rewriteValueS390X_OpLsh16x16(v *Value) bool {
+func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3295,7 +3295,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x32(v *Value) bool {
+func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
@@ -3319,7 +3319,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x64(v *Value) bool {
+func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 <t> x y)
@@ -3343,7 +3343,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x8(v *Value) bool {
+func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3371,7 +3371,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x16(v *Value) bool {
+func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3399,7 +3399,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x32(v *Value) bool {
+func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
@@ -3423,7 +3423,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x64(v *Value) bool {
+func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 <t> x y)
@@ -3447,7 +3447,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x8(v *Value) bool {
+func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3475,7 +3475,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x16(v *Value) bool {
+func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3503,7 +3503,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x32(v *Value) bool {
+func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x y)
@@ -3527,7 +3527,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x64(v *Value) bool {
+func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 <t> x y)
@@ -3551,7 +3551,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x8(v *Value) bool {
+func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3579,7 +3579,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x16(v *Value) bool {
+func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3607,7 +3607,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x32(v *Value) bool {
+func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
@@ -3631,7 +3631,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x64(v *Value) bool {
+func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 <t> x y)
@@ -3655,7 +3655,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x8(v *Value) bool {
+func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3683,7 +3683,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16(v *Value) bool {
+func rewriteValueS390X_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3704,7 +3704,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16u(v *Value) bool {
+func rewriteValueS390X_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3725,7 +3725,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32(v *Value) bool {
+func rewriteValueS390X_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3744,7 +3744,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32u(v *Value) bool {
+func rewriteValueS390X_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3763,7 +3763,7 @@
return true
}
}
-func rewriteValueS390X_OpMod64(v *Value) bool {
+func rewriteValueS390X_OpMod64_0(v *Value) bool {
// match: (Mod64 x y)
// cond:
// result: (MODD x y)
@@ -3776,7 +3776,7 @@
return true
}
}
-func rewriteValueS390X_OpMod64u(v *Value) bool {
+func rewriteValueS390X_OpMod64u_0(v *Value) bool {
// match: (Mod64u x y)
// cond:
// result: (MODDU x y)
@@ -3789,7 +3789,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8(v *Value) bool {
+func rewriteValueS390X_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3810,7 +3810,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8u(v *Value) bool {
+func rewriteValueS390X_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -3831,7 +3831,7 @@
return true
}
}
-func rewriteValueS390X_OpMove(v *Value) bool {
+func rewriteValueS390X_OpMove_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4074,6 +4074,13 @@
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [7] dst src mem)
// cond:
// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
@@ -4237,7 +4244,7 @@
}
return false
}
-func rewriteValueS390X_OpMul16(v *Value) bool {
+func rewriteValueS390X_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULLW x y)
@@ -4250,7 +4257,7 @@
return true
}
}
-func rewriteValueS390X_OpMul32(v *Value) bool {
+func rewriteValueS390X_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULLW x y)
@@ -4263,7 +4270,7 @@
return true
}
}
-func rewriteValueS390X_OpMul32F(v *Value) bool {
+func rewriteValueS390X_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
@@ -4276,7 +4283,7 @@
return true
}
}
-func rewriteValueS390X_OpMul64(v *Value) bool {
+func rewriteValueS390X_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULLD x y)
@@ -4289,7 +4296,7 @@
return true
}
}
-func rewriteValueS390X_OpMul64F(v *Value) bool {
+func rewriteValueS390X_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMUL x y)
@@ -4302,7 +4309,7 @@
return true
}
}
-func rewriteValueS390X_OpMul8(v *Value) bool {
+func rewriteValueS390X_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULLW x y)
@@ -4315,7 +4322,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg16(v *Value) bool {
+func rewriteValueS390X_OpNeg16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4332,7 +4339,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg32(v *Value) bool {
+func rewriteValueS390X_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGW x)
@@ -4343,7 +4350,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg32F(v *Value) bool {
+func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEGS x)
@@ -4354,7 +4361,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg64(v *Value) bool {
+func rewriteValueS390X_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
@@ -4365,7 +4372,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg64F(v *Value) bool {
+func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEG x)
@@ -4376,7 +4383,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg8(v *Value) bool {
+func rewriteValueS390X_OpNeg8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4393,7 +4400,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq16(v *Value) bool {
+func rewriteValueS390X_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4422,7 +4429,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32(v *Value) bool {
+func rewriteValueS390X_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4447,7 +4454,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32F(v *Value) bool {
+func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4472,7 +4479,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64(v *Value) bool {
+func rewriteValueS390X_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4497,7 +4504,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64F(v *Value) bool {
+func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4522,7 +4529,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq8(v *Value) bool {
+func rewriteValueS390X_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4551,7 +4558,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqB(v *Value) bool {
+func rewriteValueS390X_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4580,7 +4587,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqPtr(v *Value) bool {
+func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4605,7 +4612,7 @@
return true
}
}
-func rewriteValueS390X_OpNilCheck(v *Value) bool {
+func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
@@ -4618,7 +4625,7 @@
return true
}
}
-func rewriteValueS390X_OpNot(v *Value) bool {
+func rewriteValueS390X_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORWconst [1] x)
@@ -4630,7 +4637,7 @@
return true
}
}
-func rewriteValueS390X_OpOffPtr(v *Value) bool {
+func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4677,7 +4684,7 @@
return true
}
}
-func rewriteValueS390X_OpOr16(v *Value) bool {
+func rewriteValueS390X_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORW x y)
@@ -4690,7 +4697,7 @@
return true
}
}
-func rewriteValueS390X_OpOr32(v *Value) bool {
+func rewriteValueS390X_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORW x y)
@@ -4703,7 +4710,7 @@
return true
}
}
-func rewriteValueS390X_OpOr64(v *Value) bool {
+func rewriteValueS390X_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
@@ -4716,7 +4723,7 @@
return true
}
}
-func rewriteValueS390X_OpOr8(v *Value) bool {
+func rewriteValueS390X_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORW x y)
@@ -4729,7 +4736,7 @@
return true
}
}
-func rewriteValueS390X_OpOrB(v *Value) bool {
+func rewriteValueS390X_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORW x y)
@@ -4742,7 +4749,7 @@
return true
}
}
-func rewriteValueS390X_OpRound32F(v *Value) bool {
+func rewriteValueS390X_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: (LoweredRound32F x)
@@ -4753,7 +4760,7 @@
return true
}
}
-func rewriteValueS390X_OpRound64F(v *Value) bool {
+func rewriteValueS390X_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: (LoweredRound64F x)
@@ -4764,7 +4771,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4794,7 +4801,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4822,7 +4829,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4850,7 +4857,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4880,7 +4887,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x16(v *Value) bool {
+func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4913,7 +4920,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x32(v *Value) bool {
+func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4944,7 +4951,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x64(v *Value) bool {
+func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -4975,7 +4982,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x8(v *Value) bool {
+func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5008,7 +5015,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5036,7 +5043,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
@@ -5060,7 +5067,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux64 <t> x y)
@@ -5084,7 +5091,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5112,7 +5119,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x16(v *Value) bool {
+func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5143,7 +5150,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x32(v *Value) bool {
+func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
@@ -5170,7 +5177,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x64(v *Value) bool {
+func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x64 <t> x y)
@@ -5197,7 +5204,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x8(v *Value) bool {
+func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5228,7 +5235,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5256,7 +5263,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x y)
@@ -5280,7 +5287,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 <t> x y)
@@ -5304,7 +5311,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5332,7 +5339,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x16(v *Value) bool {
+func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5363,7 +5370,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x32(v *Value) bool {
+func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x y)
@@ -5390,7 +5397,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x64(v *Value) bool {
+func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 <t> x y)
@@ -5417,7 +5424,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x8(v *Value) bool {
+func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5448,7 +5455,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5478,7 +5485,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5506,7 +5513,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5534,7 +5541,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5564,7 +5571,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x16(v *Value) bool {
+func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5597,7 +5604,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x32(v *Value) bool {
+func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5628,7 +5635,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x64(v *Value) bool {
+func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5659,7 +5666,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x8(v *Value) bool {
+func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -5692,7 +5699,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XADD(v *Value) bool {
+func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
// match: (ADD x (MOVDconst [c]))
// cond: is32Bit(c)
// result: (ADDconst [c] x)
@@ -5907,6 +5914,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ADDload <t> [off] {sym} x ptr mem)
@@ -5961,7 +5971,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDW(v *Value) bool {
+func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
// match: (ADDW x (MOVDconst [c]))
// cond:
// result: (ADDWconst [c] x)
@@ -6178,6 +6188,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ADDWload <t> [off] {sym} x ptr mem)
@@ -6284,7 +6297,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
// match: (ADDWconst [c] x)
// cond: int32(c)==0
// result: x
@@ -6331,7 +6344,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
// cond: ((c+d)&1 == 0) && is32Bit(c+d)
// result: (MOVDaddr [c+d] {s} x)
@@ -6448,7 +6461,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XAND(v *Value) bool {
+func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
// match: (AND x (MOVDconst [c]))
// cond: is32Bit(c) && c < 0
// result: (ANDconst [c] x)
@@ -6617,6 +6630,9 @@
v.AuxInt = c & d
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
// match: (AND x x)
// cond:
// result: x
@@ -6736,7 +6752,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDW(v *Value) bool {
+func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
// match: (ANDW x (MOVDconst [c]))
// cond:
// result: (ANDWconst [c] x)
@@ -6962,6 +6978,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ANDWload <t> [off] {sym} x ptr mem)
@@ -6990,7 +7009,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
// match: (ANDWconst [c] (ANDWconst [d] x))
// cond:
// result: (ANDWconst [c & d] x)
@@ -7073,7 +7092,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
// match: (ANDconst [c] (ANDconst [d] x))
// cond:
// result: (ANDconst [c & d] x)
@@ -7130,7 +7149,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMP(v *Value) bool {
+func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
@@ -7173,7 +7192,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPU x (MOVDconst [c]))
@@ -7216,7 +7235,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: uint64(x)==uint64(y)
// result: (FlagEQ)
@@ -7267,7 +7286,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVDconst [c]))
@@ -7304,7 +7323,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPWU x (MOVDconst [c]))
@@ -7341,7 +7360,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: uint32(x)==uint32(y)
// result: (FlagEQ)
@@ -7392,7 +7411,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -7475,7 +7494,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
// result: (FlagEQ)
@@ -7603,7 +7622,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFADD(v *Value) bool {
+func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
// match: (FADD (FMUL y z) x)
// cond:
// result: (FMADD x y z)
@@ -7640,7 +7659,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFADDS(v *Value) bool {
+func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
// match: (FADDS (FMULS y z) x)
// cond:
// result: (FMADDS x y z)
@@ -7677,7 +7696,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (FMOVDload [off1+off2] {sym} ptr mem)
@@ -7777,7 +7796,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
@@ -7824,7 +7843,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
@@ -7932,7 +7951,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
@@ -7983,7 +8002,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (FMOVSload [off1+off2] {sym} ptr mem)
@@ -8083,7 +8102,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
@@ -8130,7 +8149,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
@@ -8238,7 +8257,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
@@ -8289,7 +8308,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
// match: (FSUB (FMUL y z) x)
// cond:
// result: (FMSUB x y z)
@@ -8309,7 +8328,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFSUBS(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
// match: (FSUBS (FMULS y z) x)
// cond:
// result: (FMSUBS x y z)
@@ -8329,7 +8348,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
// match: (LoweredRound32F x:(FMOVSconst))
// cond:
// result: x
@@ -8345,7 +8364,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
// match: (LoweredRound64F x:(FMOVDconst))
// cond:
// result: x
@@ -8361,7 +8380,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
// match: (MOVBZload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVBZreg x)
@@ -8483,7 +8502,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
@@ -8574,9 +8593,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
// result: (MOVDreg x)
@@ -8805,6 +8822,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVBZreg x:(MOVBZreg _))
// cond:
// result: (MOVDreg x)
@@ -8884,7 +8906,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVBload [off1+off2] {sym} ptr mem)
@@ -8934,7 +8956,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBreg x:(MOVBload _ _))
@@ -9017,7 +9039,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
// cond:
// result: (MOVBstore [off] {sym} ptr x mem)
@@ -9322,6 +9344,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
// result: (MOVHstore [i-1] {s} p w0 mem)
@@ -9554,7 +9579,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -9633,7 +9658,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
@@ -10028,6 +10053,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
@@ -10538,6 +10566,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool {
// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
@@ -11038,6 +11069,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool {
// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
@@ -11348,7 +11382,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool {
// match: (MOVDEQ x y (InvertFlags cmp))
// cond:
// result: (MOVDEQ x y cmp)
@@ -11410,7 +11444,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool {
// match: (MOVDGE x y (InvertFlags cmp))
// cond:
// result: (MOVDLE x y cmp)
@@ -11472,7 +11506,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool {
// match: (MOVDGT x y (InvertFlags cmp))
// cond:
// result: (MOVDLT x y cmp)
@@ -11534,7 +11568,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool {
// match: (MOVDLE x y (InvertFlags cmp))
// cond:
// result: (MOVDGE x y cmp)
@@ -11596,7 +11630,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool {
// match: (MOVDLT x y (InvertFlags cmp))
// cond:
// result: (MOVDGT x y cmp)
@@ -11658,7 +11692,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool {
// match: (MOVDNE x y (InvertFlags cmp))
// cond:
// result: (MOVDNE x y cmp)
@@ -11720,7 +11754,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
// cond: is20Bit(c+d) && x.Op != OpSB
// result: (MOVDaddridx [c+d] {s} x y)
@@ -11817,7 +11851,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
// match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDreg x)
@@ -11939,7 +11973,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
// match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
@@ -12030,7 +12064,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVDnop <t> x)
@@ -12270,6 +12304,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVDnop <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
@@ -12356,7 +12395,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVDreg <t> x)
@@ -12580,6 +12619,11 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVDreg <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
@@ -12694,7 +12738,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
@@ -12936,7 +12980,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -12986,7 +13030,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
// match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
@@ -13085,7 +13129,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
// match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstore [i-2] {s} p w mem)
@@ -13270,7 +13314,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
@@ -13771,6 +13815,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool {
// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
@@ -14081,7 +14128,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
// match: (MOVHZload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVHZreg x)
@@ -14203,7 +14250,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
// match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
@@ -14294,7 +14341,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHZreg x:(MOVBZload _ _))
@@ -14428,7 +14475,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVHload [off1+off2] {sym} ptr mem)
@@ -14478,7 +14525,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHreg x:(MOVBload _ _))
@@ -14609,7 +14656,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
// cond:
// result: (MOVHstore [off] {sym} ptr x mem)
@@ -14914,6 +14961,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
// match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem))
// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
// result: (MOVWstore [i-2] {s} p w0 mem)
@@ -14964,7 +15014,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
@@ -15043,7 +15093,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
// match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
@@ -15438,6 +15488,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool {
// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
@@ -15950,7 +16003,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
// match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDBRstore [i-4] {s} p w mem)
@@ -16044,7 +16097,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
@@ -16451,7 +16504,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
// match: (MOVWZload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVWZreg x)
@@ -16573,7 +16626,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
// match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
@@ -16664,7 +16717,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWZreg x:(MOVBZload _ _))
@@ -16822,7 +16875,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVWload [off1+off2] {sym} ptr mem)
@@ -16872,9 +16925,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
@@ -16999,6 +17050,11 @@
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVWreg x:(MOVWreg _))
// cond:
// result: (MOVDreg x)
@@ -17051,7 +17107,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
@@ -17348,6 +17404,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
// match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
// result: (STM3 [i-8] {s} p w0 w1 w2 mem)
@@ -17426,7 +17485,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -17512,7 +17571,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
// match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
@@ -17907,6 +17966,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool {
// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
@@ -18015,7 +18077,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLD(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
// match: (MULLD x (MOVDconst [c]))
// cond: is32Bit(c)
// result: (MULLDconst [c] x)
@@ -18158,7 +18220,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLDconst [-1] x)
@@ -18261,7 +18323,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLW(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
// match: (MULLW x (MOVDconst [c]))
// cond:
// result: (MULLWconst [c] x)
@@ -18502,7 +18564,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLWconst [-1] x)
@@ -18605,7 +18667,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEG(v *Value) bool {
+func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
// match: (NEG (MOVDconst [c]))
// cond:
// result: (MOVDconst [-c])
@@ -18643,7 +18705,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEGW(v *Value) bool {
+func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
// match: (NEGW (MOVDconst [c]))
// cond:
// result: (MOVDconst [int64(int32(-c))])
@@ -18659,7 +18721,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNOT(v *Value) bool {
+func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
@@ -18681,7 +18743,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNOTW(v *Value) bool {
+func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
// match: (NOTW x)
// cond: true
// result: (XORWconst [-1] x)
@@ -18697,11 +18759,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XOR(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
// match: (OR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (ORconst [c] x)
@@ -18917,6 +18975,13 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ORload <t> [off] {sym} x ptr mem)
@@ -19399,6 +19464,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
@@ -19954,6 +20026,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
@@ -20464,6 +20543,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
@@ -20988,6 +21074,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -21638,6 +21731,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -22288,6 +22388,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
@@ -22938,6 +23045,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
@@ -23505,6 +23619,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
@@ -24112,6 +24233,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
@@ -24698,6 +24826,13 @@
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
@@ -25298,6 +25433,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -25968,6 +26110,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_130(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -26678,6 +26827,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_140(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
@@ -27428,6 +27584,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_150(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
@@ -27505,11 +27668,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORW(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
// match: (ORW x (MOVDconst [c]))
// cond:
// result: (ORWconst [c] x)
@@ -27735,6 +27894,13 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ORWload <t> [off] {sym} x ptr mem)
@@ -28177,6 +28343,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
@@ -28696,6 +28869,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
@@ -29248,6 +29428,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -29898,6 +30085,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -30483,6 +30677,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
@@ -31028,6 +31229,13 @@
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
@@ -31642,6 +31850,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -32312,6 +32527,13 @@
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
@@ -32515,7 +32737,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
// match: (ORWconst [c] x)
// cond: int32(c)==0
// result: x
@@ -32558,7 +32780,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
@@ -32599,7 +32821,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLD(v *Value) bool {
+func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
// match: (SLD x (MOVDconst [c]))
// cond:
// result: (SLDconst [c&63] x)
@@ -32635,7 +32857,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLW(v *Value) bool {
+func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
// match: (SLW x (MOVDconst [c]))
// cond:
// result: (SLWconst [c&63] x)
@@ -32671,7 +32893,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
// match: (SRAD x (MOVDconst [c]))
// cond:
// result: (SRADconst [c&63] x)
@@ -32707,7 +32929,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
// match: (SRADconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [d>>uint64(c)])
@@ -32724,7 +32946,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
// match: (SRAW x (MOVDconst [c]))
// cond:
// result: (SRAWconst [c&63] x)
@@ -32760,7 +32982,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
// match: (SRAWconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [d>>uint64(c)])
@@ -32777,7 +32999,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
// match: (SRD x (MOVDconst [c]))
// cond:
// result: (SRDconst [c&63] x)
@@ -32813,7 +33035,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
// match: (SRW x (MOVDconst [c]))
// cond:
// result: (SRWconst [c&63] x)
@@ -32849,7 +33071,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTM2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
// match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
// result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem)
@@ -32918,7 +33140,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTMG2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
// match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-16) && clobber(x)
// result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem)
@@ -32960,7 +33182,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUB x (MOVDconst [c]))
@@ -33041,7 +33263,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEWcarrymask_0(v *Value) bool {
// match: (SUBEWcarrymask (FlagEQ))
// cond:
// result: (MOVDconst [-1])
@@ -33080,7 +33302,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEcarrymask_0(v *Value) bool {
// match: (SUBEcarrymask (FlagEQ))
// cond:
// result: (MOVDconst [-1])
@@ -33119,7 +33341,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBW(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBW x (MOVDconst [c]))
@@ -33220,7 +33442,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
// match: (SUBWconst [c] x)
// cond: int32(c) == 0
// result: x
@@ -33247,7 +33469,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSUBconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
@@ -33310,7 +33532,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXOR(v *Value) bool {
+func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
// match: (XOR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (XORconst [c] x)
@@ -33525,6 +33747,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XXOR_10(v *Value) bool {
// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (XORload <t> [off] {sym} x ptr mem)
@@ -33553,7 +33778,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORW(v *Value) bool {
+func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
// match: (XORW x (MOVDconst [c]))
// cond:
// result: (XORWconst [c] x)
@@ -33778,6 +34003,9 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XXORW_10(v *Value) bool {
// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (XORWload <t> [off] {sym} x ptr mem)
@@ -33858,7 +34086,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
// match: (XORWconst [c] x)
// cond: int32(c)==0
// result: x
@@ -33889,7 +34117,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
@@ -33919,7 +34147,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect0(v *Value) bool {
+func rewriteValueS390X_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
// match: (Select0 <t> (AddTupleFirst32 tuple val))
@@ -33960,7 +34188,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect1(v *Value) bool {
+func rewriteValueS390X_OpSelect1_0(v *Value) bool {
// match: (Select1 (AddTupleFirst32 tuple _))
// cond:
// result: (Select1 tuple)
@@ -33989,7 +34217,7 @@
}
return false
}
-func rewriteValueS390X_OpSignExt16to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
@@ -34000,7 +34228,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt16to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
@@ -34011,7 +34239,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt32to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
@@ -34022,7 +34250,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to16(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
@@ -34033,7 +34261,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
@@ -34044,7 +34272,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
@@ -34055,7 +34283,7 @@
return true
}
}
-func rewriteValueS390X_OpSlicemask(v *Value) bool {
+func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
@@ -34072,7 +34300,7 @@
return true
}
}
-func rewriteValueS390X_OpSqrt(v *Value) bool {
+func rewriteValueS390X_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRT x)
@@ -34083,7 +34311,7 @@
return true
}
}
-func rewriteValueS390X_OpStaticCall(v *Value) bool {
+func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
@@ -34098,7 +34326,7 @@
return true
}
}
-func rewriteValueS390X_OpStore(v *Value) bool {
+func rewriteValueS390X_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
@@ -34203,7 +34431,7 @@
}
return false
}
-func rewriteValueS390X_OpSub16(v *Value) bool {
+func rewriteValueS390X_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBW x y)
@@ -34216,7 +34444,7 @@
return true
}
}
-func rewriteValueS390X_OpSub32(v *Value) bool {
+func rewriteValueS390X_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBW x y)
@@ -34229,7 +34457,7 @@
return true
}
}
-func rewriteValueS390X_OpSub32F(v *Value) bool {
+func rewriteValueS390X_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
@@ -34242,7 +34470,7 @@
return true
}
}
-func rewriteValueS390X_OpSub64(v *Value) bool {
+func rewriteValueS390X_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
@@ -34255,7 +34483,7 @@
return true
}
}
-func rewriteValueS390X_OpSub64F(v *Value) bool {
+func rewriteValueS390X_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUB x y)
@@ -34268,7 +34496,7 @@
return true
}
}
-func rewriteValueS390X_OpSub8(v *Value) bool {
+func rewriteValueS390X_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBW x y)
@@ -34281,7 +34509,7 @@
return true
}
}
-func rewriteValueS390X_OpSubPtr(v *Value) bool {
+func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
@@ -34294,7 +34522,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc16to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
@@ -34306,7 +34534,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc32to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
@@ -34318,7 +34546,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc32to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
@@ -34330,7 +34558,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
@@ -34342,7 +34570,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to32(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
@@ -34354,7 +34582,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
@@ -34366,7 +34594,7 @@
return true
}
}
-func rewriteValueS390X_OpXor16(v *Value) bool {
+func rewriteValueS390X_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORW x y)
@@ -34379,7 +34607,7 @@
return true
}
}
-func rewriteValueS390X_OpXor32(v *Value) bool {
+func rewriteValueS390X_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORW x y)
@@ -34392,7 +34620,7 @@
return true
}
}
-func rewriteValueS390X_OpXor64(v *Value) bool {
+func rewriteValueS390X_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
@@ -34405,7 +34633,7 @@
return true
}
}
-func rewriteValueS390X_OpXor8(v *Value) bool {
+func rewriteValueS390X_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORW x y)
@@ -34418,7 +34646,7 @@
return true
}
}
-func rewriteValueS390X_OpZero(v *Value) bool {
+func rewriteValueS390X_OpZero_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zero [0] _ mem)
@@ -34586,6 +34814,11 @@
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Zero [s] destptr mem)
// cond: s > 1024
// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
@@ -34608,7 +34841,7 @@
}
return false
}
-func rewriteValueS390X_OpZeroExt16to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHZreg x)
@@ -34619,7 +34852,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt16to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHZreg x)
@@ -34630,7 +34863,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt32to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWZreg x)
@@ -34641,7 +34874,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to16(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBZreg x)
@@ -34652,7 +34885,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBZreg x)
@@ -34663,7 +34896,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go
index 305fc7b..7040abb 100644
--- a/src/cmd/compile/internal/ssa/rewritedec.go
+++ b/src/cmd/compile/internal/ssa/rewritedec.go
@@ -14,31 +14,31 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
return false
}
-func rewriteValuedec_OpStringPtr(v *Value) bool {
+func rewriteValuedec_OpStringPtr_0(v *Value) bool {
// match: (StringPtr (StringMake ptr _))
// cond:
// result: ptr
diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index 4b9b378..0fe0d21 100644
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -14,123 +14,123 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index 5bd4cac..70ce0d2 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -14,417 +14,417 @@
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 @@
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
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 @@
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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 @@
}
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))])
