cmd/compile: remove chunking of rewrite rules
We added chunking of rewrite rules to speed up compiling package SSA.
This series of changes has significantly shrunk the number of
rewrite rules, and they are no longer being added nearly as fast.
Now that we are sharing v.Args across multiple rewrite rules,
there is additional benefit to having more rules in a single function.
Removing chunking now has an incidental impact on compiling package SSA,
marginally speeds up other compilation, shrinks the cmd/compile binary,
and simplifies the code.
name old time/op new time/op delta
Template 211ms ± 2% 210ms ± 2% -0.50% (p=0.000 n=91+97)
Unicode 81.9ms ± 3% 81.8ms ± 3% ~ (p=0.179 n=96+91)
GoTypes 731ms ± 2% 731ms ± 1% ~ (p=0.442 n=94+96)
Compiler 3.43s ± 2% 3.41s ± 2% -0.36% (p=0.001 n=98+94)
SSA 8.30s ± 2% 8.32s ± 2% +0.19% (p=0.034 n=94+95)
Flate 135ms ± 2% 134ms ± 1% -0.30% (p=0.006 n=98+94)
GoParser 167ms ± 1% 167ms ± 1% -0.22% (p=0.001 n=92+94)
Reflect 453ms ± 2% 453ms ± 3% ~ (p=0.306 n=98+97)
Tar 184ms ± 2% 183ms ± 2% -0.31% (p=0.012 n=94+94)
XML 249ms ± 2% 248ms ± 1% -0.26% (p=0.002 n=96+92)
[Geo mean] 419ms 418ms -0.21%
name old user-time/op new user-time/op delta
Template 273ms ± 2% 272ms ± 2% -0.46% (p=0.000 n=93+96)
Unicode 116ms ± 4% 117ms ± 4% ~ (p=0.433 n=98+98)
GoTypes 977ms ± 2% 977ms ± 1% ~ (p=0.971 n=92+99)
Compiler 4.56s ± 6% 4.53s ± 6% ~ (p=0.081 n=100+100)
SSA 11.1s ± 2% 11.1s ± 2% ~ (p=0.064 n=99+96)
Flate 167ms ± 2% 167ms ± 1% -0.24% (p=0.004 n=95+96)
GoParser 203ms ± 1% 203ms ± 2% -0.14% (p=0.049 n=96+97)
Reflect 595ms ± 2% 595ms ± 2% ~ (p=0.544 n=95+92)
Tar 225ms ± 2% 224ms ± 2% ~ (p=0.562 n=99+99)
XML 312ms ± 2% 311ms ± 1% ~ (p=0.050 n=97+93)
[Geo mean] 543ms 542ms -0.13%
Change-Id: I8d34ab59f154b28f20c6f9e416b976bfce339baa
Reviewed-on: https://go-review.googlesource.com/c/go/+/216220
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
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 f1cfa18..2e5f3d2 100644
--- a/src/cmd/compile/internal/ssa/gen/rulegen.go
+++ b/src/cmd/compile/internal/ssa/gen/rulegen.go
@@ -170,7 +170,6 @@
sort.Strings(ops)
genFile := &File{arch: arch, suffix: suff}
- const chunkSize = 10
// Main rewrite routine is a switch on v.Op.
fn := &Func{kind: "Value", arglen: -1}
@@ -185,12 +184,8 @@
continue
}
- var ors []string
- for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
- ors = append(ors, fmt.Sprintf("rewriteValue%s%s_%s_%d(v)", arch.name, suff, op, chunk))
- }
swc := &Case{expr: exprf(op)}
- swc.add(stmtf("return %s", strings.Join(ors, " || ")))
+ swc.add(stmtf("return rewriteValue%s%s_%s(v)", arch.name, suff, op))
sw.add(swc)
}
fn.add(sw)
@@ -206,48 +201,41 @@
continue
}
- // rr is kept between chunks, so that a following chunk checks
- // that the previous one ended with a rule that wasn't
- // unconditional.
+ // rr is kept between iterations, so that each rule can check
+ // that the previous rule wasn't unconditional.
var rr *RuleRewrite
- for chunk := 0; chunk < len(rules); chunk += chunkSize {
- endchunk := chunk + chunkSize
- if endchunk > len(rules) {
- endchunk = len(rules)
- }
- fn := &Func{
- kind: "Value",
- suffix: fmt.Sprintf("_%s_%d", op, chunk),
- arglen: opByName(arch, op).argLength,
- }
- fn.add(declf("b", "v.Block"))
- fn.add(declf("config", "b.Func.Config"))
- fn.add(declf("fe", "b.Func.fe"))
- fn.add(declf("typ", "&b.Func.Config.Types"))
- for _, rule := range rules[chunk:endchunk] {
- if rr != nil && !rr.canFail {
- log.Fatalf("unconditional rule %s is followed by other rules", rr.match)
- }
- rr = &RuleRewrite{loc: rule.loc}
- rr.match, rr.cond, rr.result = rule.parse()
- pos, _ := genMatch(rr, arch, rr.match, fn.arglen >= 0)
- if pos == "" {
- pos = "v.Pos"
- }
- if rr.cond != "" {
- rr.add(breakf("!(%s)", rr.cond))
- }
- genResult(rr, arch, rr.result, pos)
- if *genLog {
- rr.add(stmtf("logRule(%q)", rule.loc))
- }
- fn.add(rr)
- }
- if rr.canFail {
- fn.add(stmtf("return false"))
- }
- genFile.add(fn)
+ fn := &Func{
+ kind: "Value",
+ suffix: fmt.Sprintf("_%s", op),
+ arglen: opByName(arch, op).argLength,
}
+ fn.add(declf("b", "v.Block"))
+ fn.add(declf("config", "b.Func.Config"))
+ fn.add(declf("fe", "b.Func.fe"))
+ fn.add(declf("typ", "&b.Func.Config.Types"))
+ for _, rule := range rules {
+ if rr != nil && !rr.canFail {
+ log.Fatalf("unconditional rule %s is followed by other rules", rr.match)
+ }
+ rr = &RuleRewrite{loc: rule.loc}
+ rr.match, rr.cond, rr.result = rule.parse()
+ pos, _ := genMatch(rr, arch, rr.match, fn.arglen >= 0)
+ if pos == "" {
+ pos = "v.Pos"
+ }
+ if rr.cond != "" {
+ rr.add(breakf("!(%s)", rr.cond))
+ }
+ genResult(rr, arch, rr.result, pos)
+ if *genLog {
+ rr.add(stmtf("logRule(%q)", rule.loc))
+ }
+ fn.add(rr)
+ }
+ if rr.canFail {
+ fn.add(stmtf("return false"))
+ }
+ genFile.add(fn)
}
// 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 35de8bc..02716a3 100644
--- a/src/cmd/compile/internal/ssa/rewrite386.go
+++ b/src/cmd/compile/internal/ssa/rewrite386.go
@@ -9,705 +9,705 @@
func rewriteValue386(v *Value) bool {
switch v.Op {
case Op386ADCL:
- return rewriteValue386_Op386ADCL_0(v)
+ return rewriteValue386_Op386ADCL(v)
case Op386ADDL:
- return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v)
+ return rewriteValue386_Op386ADDL(v)
case Op386ADDLcarry:
- return rewriteValue386_Op386ADDLcarry_0(v)
+ return rewriteValue386_Op386ADDLcarry(v)
case Op386ADDLconst:
- return rewriteValue386_Op386ADDLconst_0(v)
+ return rewriteValue386_Op386ADDLconst(v)
case Op386ADDLconstmodify:
- return rewriteValue386_Op386ADDLconstmodify_0(v)
+ return rewriteValue386_Op386ADDLconstmodify(v)
case Op386ADDLconstmodifyidx4:
- return rewriteValue386_Op386ADDLconstmodifyidx4_0(v)
+ return rewriteValue386_Op386ADDLconstmodifyidx4(v)
case Op386ADDLload:
- return rewriteValue386_Op386ADDLload_0(v)
+ return rewriteValue386_Op386ADDLload(v)
case Op386ADDLloadidx4:
- return rewriteValue386_Op386ADDLloadidx4_0(v)
+ return rewriteValue386_Op386ADDLloadidx4(v)
case Op386ADDLmodify:
- return rewriteValue386_Op386ADDLmodify_0(v)
+ return rewriteValue386_Op386ADDLmodify(v)
case Op386ADDLmodifyidx4:
- return rewriteValue386_Op386ADDLmodifyidx4_0(v)
+ return rewriteValue386_Op386ADDLmodifyidx4(v)
case Op386ADDSD:
- return rewriteValue386_Op386ADDSD_0(v)
+ return rewriteValue386_Op386ADDSD(v)
case Op386ADDSDload:
- return rewriteValue386_Op386ADDSDload_0(v)
+ return rewriteValue386_Op386ADDSDload(v)
case Op386ADDSS:
- return rewriteValue386_Op386ADDSS_0(v)
+ return rewriteValue386_Op386ADDSS(v)
case Op386ADDSSload:
- return rewriteValue386_Op386ADDSSload_0(v)
+ return rewriteValue386_Op386ADDSSload(v)
case Op386ANDL:
- return rewriteValue386_Op386ANDL_0(v)
+ return rewriteValue386_Op386ANDL(v)
case Op386ANDLconst:
- return rewriteValue386_Op386ANDLconst_0(v)
+ return rewriteValue386_Op386ANDLconst(v)
case Op386ANDLconstmodify:
- return rewriteValue386_Op386ANDLconstmodify_0(v)
+ return rewriteValue386_Op386ANDLconstmodify(v)
case Op386ANDLconstmodifyidx4:
- return rewriteValue386_Op386ANDLconstmodifyidx4_0(v)
+ return rewriteValue386_Op386ANDLconstmodifyidx4(v)
case Op386ANDLload:
- return rewriteValue386_Op386ANDLload_0(v)
+ return rewriteValue386_Op386ANDLload(v)
case Op386ANDLloadidx4:
- return rewriteValue386_Op386ANDLloadidx4_0(v)
+ return rewriteValue386_Op386ANDLloadidx4(v)
case Op386ANDLmodify:
- return rewriteValue386_Op386ANDLmodify_0(v)
+ return rewriteValue386_Op386ANDLmodify(v)
case Op386ANDLmodifyidx4:
- return rewriteValue386_Op386ANDLmodifyidx4_0(v)
+ return rewriteValue386_Op386ANDLmodifyidx4(v)
case Op386CMPB:
- return rewriteValue386_Op386CMPB_0(v)
+ return rewriteValue386_Op386CMPB(v)
case Op386CMPBconst:
- return rewriteValue386_Op386CMPBconst_0(v)
+ return rewriteValue386_Op386CMPBconst(v)
case Op386CMPBload:
- return rewriteValue386_Op386CMPBload_0(v)
+ return rewriteValue386_Op386CMPBload(v)
case Op386CMPL:
- return rewriteValue386_Op386CMPL_0(v)
+ return rewriteValue386_Op386CMPL(v)
case Op386CMPLconst:
- return rewriteValue386_Op386CMPLconst_0(v) || rewriteValue386_Op386CMPLconst_10(v)
+ return rewriteValue386_Op386CMPLconst(v)
case Op386CMPLload:
- return rewriteValue386_Op386CMPLload_0(v)
+ return rewriteValue386_Op386CMPLload(v)
case Op386CMPW:
- return rewriteValue386_Op386CMPW_0(v)
+ return rewriteValue386_Op386CMPW(v)
case Op386CMPWconst:
- return rewriteValue386_Op386CMPWconst_0(v)
+ return rewriteValue386_Op386CMPWconst(v)
case Op386CMPWload:
- return rewriteValue386_Op386CMPWload_0(v)
+ return rewriteValue386_Op386CMPWload(v)
case Op386DIVSD:
- return rewriteValue386_Op386DIVSD_0(v)
+ return rewriteValue386_Op386DIVSD(v)
case Op386DIVSDload:
- return rewriteValue386_Op386DIVSDload_0(v)
+ return rewriteValue386_Op386DIVSDload(v)
case Op386DIVSS:
- return rewriteValue386_Op386DIVSS_0(v)
+ return rewriteValue386_Op386DIVSS(v)
case Op386DIVSSload:
- return rewriteValue386_Op386DIVSSload_0(v)
+ return rewriteValue386_Op386DIVSSload(v)
case Op386LEAL:
- return rewriteValue386_Op386LEAL_0(v)
+ return rewriteValue386_Op386LEAL(v)
case Op386LEAL1:
- return rewriteValue386_Op386LEAL1_0(v)
+ return rewriteValue386_Op386LEAL1(v)
case Op386LEAL2:
- return rewriteValue386_Op386LEAL2_0(v)
+ return rewriteValue386_Op386LEAL2(v)
case Op386LEAL4:
- return rewriteValue386_Op386LEAL4_0(v)
+ return rewriteValue386_Op386LEAL4(v)
case Op386LEAL8:
- return rewriteValue386_Op386LEAL8_0(v)
+ return rewriteValue386_Op386LEAL8(v)
case Op386MOVBLSX:
- return rewriteValue386_Op386MOVBLSX_0(v)
+ return rewriteValue386_Op386MOVBLSX(v)
case Op386MOVBLSXload:
- return rewriteValue386_Op386MOVBLSXload_0(v)
+ return rewriteValue386_Op386MOVBLSXload(v)
case Op386MOVBLZX:
- return rewriteValue386_Op386MOVBLZX_0(v)
+ return rewriteValue386_Op386MOVBLZX(v)
case Op386MOVBload:
- return rewriteValue386_Op386MOVBload_0(v)
+ return rewriteValue386_Op386MOVBload(v)
case Op386MOVBloadidx1:
- return rewriteValue386_Op386MOVBloadidx1_0(v)
+ return rewriteValue386_Op386MOVBloadidx1(v)
case Op386MOVBstore:
- return rewriteValue386_Op386MOVBstore_0(v) || rewriteValue386_Op386MOVBstore_10(v)
+ return rewriteValue386_Op386MOVBstore(v)
case Op386MOVBstoreconst:
- return rewriteValue386_Op386MOVBstoreconst_0(v)
+ return rewriteValue386_Op386MOVBstoreconst(v)
case Op386MOVBstoreconstidx1:
- return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
+ return rewriteValue386_Op386MOVBstoreconstidx1(v)
case Op386MOVBstoreidx1:
- return rewriteValue386_Op386MOVBstoreidx1_0(v)
+ return rewriteValue386_Op386MOVBstoreidx1(v)
case Op386MOVLload:
- return rewriteValue386_Op386MOVLload_0(v)
+ return rewriteValue386_Op386MOVLload(v)
case Op386MOVLloadidx1:
- return rewriteValue386_Op386MOVLloadidx1_0(v)
+ return rewriteValue386_Op386MOVLloadidx1(v)
case Op386MOVLloadidx4:
- return rewriteValue386_Op386MOVLloadidx4_0(v)
+ return rewriteValue386_Op386MOVLloadidx4(v)
case Op386MOVLstore:
- return rewriteValue386_Op386MOVLstore_0(v) || rewriteValue386_Op386MOVLstore_10(v)
+ return rewriteValue386_Op386MOVLstore(v)
case Op386MOVLstoreconst:
- return rewriteValue386_Op386MOVLstoreconst_0(v)
+ return rewriteValue386_Op386MOVLstoreconst(v)
case Op386MOVLstoreconstidx1:
- return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
+ return rewriteValue386_Op386MOVLstoreconstidx1(v)
case Op386MOVLstoreconstidx4:
- return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
+ return rewriteValue386_Op386MOVLstoreconstidx4(v)
case Op386MOVLstoreidx1:
- return rewriteValue386_Op386MOVLstoreidx1_0(v)
+ return rewriteValue386_Op386MOVLstoreidx1(v)
case Op386MOVLstoreidx4:
- return rewriteValue386_Op386MOVLstoreidx4_0(v) || rewriteValue386_Op386MOVLstoreidx4_10(v)
+ return rewriteValue386_Op386MOVLstoreidx4(v)
case Op386MOVSDconst:
- return rewriteValue386_Op386MOVSDconst_0(v)
+ return rewriteValue386_Op386MOVSDconst(v)
case Op386MOVSDload:
- return rewriteValue386_Op386MOVSDload_0(v)
+ return rewriteValue386_Op386MOVSDload(v)
case Op386MOVSDloadidx1:
- return rewriteValue386_Op386MOVSDloadidx1_0(v)
+ return rewriteValue386_Op386MOVSDloadidx1(v)
case Op386MOVSDloadidx8:
- return rewriteValue386_Op386MOVSDloadidx8_0(v)
+ return rewriteValue386_Op386MOVSDloadidx8(v)
case Op386MOVSDstore:
- return rewriteValue386_Op386MOVSDstore_0(v)
+ return rewriteValue386_Op386MOVSDstore(v)
case Op386MOVSDstoreidx1:
- return rewriteValue386_Op386MOVSDstoreidx1_0(v)
+ return rewriteValue386_Op386MOVSDstoreidx1(v)
case Op386MOVSDstoreidx8:
- return rewriteValue386_Op386MOVSDstoreidx8_0(v)
+ return rewriteValue386_Op386MOVSDstoreidx8(v)
case Op386MOVSSconst:
- return rewriteValue386_Op386MOVSSconst_0(v)
+ return rewriteValue386_Op386MOVSSconst(v)
case Op386MOVSSload:
- return rewriteValue386_Op386MOVSSload_0(v)
+ return rewriteValue386_Op386MOVSSload(v)
case Op386MOVSSloadidx1:
- return rewriteValue386_Op386MOVSSloadidx1_0(v)
+ return rewriteValue386_Op386MOVSSloadidx1(v)
case Op386MOVSSloadidx4:
- return rewriteValue386_Op386MOVSSloadidx4_0(v)
+ return rewriteValue386_Op386MOVSSloadidx4(v)
case Op386MOVSSstore:
- return rewriteValue386_Op386MOVSSstore_0(v)
+ return rewriteValue386_Op386MOVSSstore(v)
case Op386MOVSSstoreidx1:
- return rewriteValue386_Op386MOVSSstoreidx1_0(v)
+ return rewriteValue386_Op386MOVSSstoreidx1(v)
case Op386MOVSSstoreidx4:
- return rewriteValue386_Op386MOVSSstoreidx4_0(v)
+ return rewriteValue386_Op386MOVSSstoreidx4(v)
case Op386MOVWLSX:
- return rewriteValue386_Op386MOVWLSX_0(v)
+ return rewriteValue386_Op386MOVWLSX(v)
case Op386MOVWLSXload:
- return rewriteValue386_Op386MOVWLSXload_0(v)
+ return rewriteValue386_Op386MOVWLSXload(v)
case Op386MOVWLZX:
- return rewriteValue386_Op386MOVWLZX_0(v)
+ return rewriteValue386_Op386MOVWLZX(v)
case Op386MOVWload:
- return rewriteValue386_Op386MOVWload_0(v)
+ return rewriteValue386_Op386MOVWload(v)
case Op386MOVWloadidx1:
- return rewriteValue386_Op386MOVWloadidx1_0(v)
+ return rewriteValue386_Op386MOVWloadidx1(v)
case Op386MOVWloadidx2:
- return rewriteValue386_Op386MOVWloadidx2_0(v)
+ return rewriteValue386_Op386MOVWloadidx2(v)
case Op386MOVWstore:
- return rewriteValue386_Op386MOVWstore_0(v)
+ return rewriteValue386_Op386MOVWstore(v)
case Op386MOVWstoreconst:
- return rewriteValue386_Op386MOVWstoreconst_0(v)
+ return rewriteValue386_Op386MOVWstoreconst(v)
case Op386MOVWstoreconstidx1:
- return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
+ return rewriteValue386_Op386MOVWstoreconstidx1(v)
case Op386MOVWstoreconstidx2:
- return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
+ return rewriteValue386_Op386MOVWstoreconstidx2(v)
case Op386MOVWstoreidx1:
- return rewriteValue386_Op386MOVWstoreidx1_0(v)
+ return rewriteValue386_Op386MOVWstoreidx1(v)
case Op386MOVWstoreidx2:
- return rewriteValue386_Op386MOVWstoreidx2_0(v)
+ return rewriteValue386_Op386MOVWstoreidx2(v)
case Op386MULL:
- return rewriteValue386_Op386MULL_0(v)
+ return rewriteValue386_Op386MULL(v)
case Op386MULLconst:
- return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v) || rewriteValue386_Op386MULLconst_30(v)
+ return rewriteValue386_Op386MULLconst(v)
case Op386MULLload:
- return rewriteValue386_Op386MULLload_0(v)
+ return rewriteValue386_Op386MULLload(v)
case Op386MULLloadidx4:
- return rewriteValue386_Op386MULLloadidx4_0(v)
+ return rewriteValue386_Op386MULLloadidx4(v)
case Op386MULSD:
- return rewriteValue386_Op386MULSD_0(v)
+ return rewriteValue386_Op386MULSD(v)
case Op386MULSDload:
- return rewriteValue386_Op386MULSDload_0(v)
+ return rewriteValue386_Op386MULSDload(v)
case Op386MULSS:
- return rewriteValue386_Op386MULSS_0(v)
+ return rewriteValue386_Op386MULSS(v)
case Op386MULSSload:
- return rewriteValue386_Op386MULSSload_0(v)
+ return rewriteValue386_Op386MULSSload(v)
case Op386NEGL:
- return rewriteValue386_Op386NEGL_0(v)
+ return rewriteValue386_Op386NEGL(v)
case Op386NOTL:
- return rewriteValue386_Op386NOTL_0(v)
+ return rewriteValue386_Op386NOTL(v)
case Op386ORL:
- return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v)
+ return rewriteValue386_Op386ORL(v)
case Op386ORLconst:
- return rewriteValue386_Op386ORLconst_0(v)
+ return rewriteValue386_Op386ORLconst(v)
case Op386ORLconstmodify:
- return rewriteValue386_Op386ORLconstmodify_0(v)
+ return rewriteValue386_Op386ORLconstmodify(v)
case Op386ORLconstmodifyidx4:
- return rewriteValue386_Op386ORLconstmodifyidx4_0(v)
+ return rewriteValue386_Op386ORLconstmodifyidx4(v)
case Op386ORLload:
- return rewriteValue386_Op386ORLload_0(v)
+ return rewriteValue386_Op386ORLload(v)
case Op386ORLloadidx4:
- return rewriteValue386_Op386ORLloadidx4_0(v)
+ return rewriteValue386_Op386ORLloadidx4(v)
case Op386ORLmodify:
- return rewriteValue386_Op386ORLmodify_0(v)
+ return rewriteValue386_Op386ORLmodify(v)
case Op386ORLmodifyidx4:
- return rewriteValue386_Op386ORLmodifyidx4_0(v)
+ return rewriteValue386_Op386ORLmodifyidx4(v)
case Op386ROLBconst:
- return rewriteValue386_Op386ROLBconst_0(v)
+ return rewriteValue386_Op386ROLBconst(v)
case Op386ROLLconst:
- return rewriteValue386_Op386ROLLconst_0(v)
+ return rewriteValue386_Op386ROLLconst(v)
case Op386ROLWconst:
- return rewriteValue386_Op386ROLWconst_0(v)
+ return rewriteValue386_Op386ROLWconst(v)
case Op386SARB:
- return rewriteValue386_Op386SARB_0(v)
+ return rewriteValue386_Op386SARB(v)
case Op386SARBconst:
- return rewriteValue386_Op386SARBconst_0(v)
+ return rewriteValue386_Op386SARBconst(v)
case Op386SARL:
- return rewriteValue386_Op386SARL_0(v)
+ return rewriteValue386_Op386SARL(v)
case Op386SARLconst:
- return rewriteValue386_Op386SARLconst_0(v)
+ return rewriteValue386_Op386SARLconst(v)
case Op386SARW:
- return rewriteValue386_Op386SARW_0(v)
+ return rewriteValue386_Op386SARW(v)
case Op386SARWconst:
- return rewriteValue386_Op386SARWconst_0(v)
+ return rewriteValue386_Op386SARWconst(v)
case Op386SBBL:
- return rewriteValue386_Op386SBBL_0(v)
+ return rewriteValue386_Op386SBBL(v)
case Op386SBBLcarrymask:
- return rewriteValue386_Op386SBBLcarrymask_0(v)
+ return rewriteValue386_Op386SBBLcarrymask(v)
case Op386SETA:
- return rewriteValue386_Op386SETA_0(v)
+ return rewriteValue386_Op386SETA(v)
case Op386SETAE:
- return rewriteValue386_Op386SETAE_0(v)
+ return rewriteValue386_Op386SETAE(v)
case Op386SETB:
- return rewriteValue386_Op386SETB_0(v)
+ return rewriteValue386_Op386SETB(v)
case Op386SETBE:
- return rewriteValue386_Op386SETBE_0(v)
+ return rewriteValue386_Op386SETBE(v)
case Op386SETEQ:
- return rewriteValue386_Op386SETEQ_0(v)
+ return rewriteValue386_Op386SETEQ(v)
case Op386SETG:
- return rewriteValue386_Op386SETG_0(v)
+ return rewriteValue386_Op386SETG(v)
case Op386SETGE:
- return rewriteValue386_Op386SETGE_0(v)
+ return rewriteValue386_Op386SETGE(v)
case Op386SETL:
- return rewriteValue386_Op386SETL_0(v)
+ return rewriteValue386_Op386SETL(v)
case Op386SETLE:
- return rewriteValue386_Op386SETLE_0(v)
+ return rewriteValue386_Op386SETLE(v)
case Op386SETNE:
- return rewriteValue386_Op386SETNE_0(v)
+ return rewriteValue386_Op386SETNE(v)
case Op386SHLL:
- return rewriteValue386_Op386SHLL_0(v)
+ return rewriteValue386_Op386SHLL(v)
case Op386SHLLconst:
- return rewriteValue386_Op386SHLLconst_0(v)
+ return rewriteValue386_Op386SHLLconst(v)
case Op386SHRB:
- return rewriteValue386_Op386SHRB_0(v)
+ return rewriteValue386_Op386SHRB(v)
case Op386SHRBconst:
- return rewriteValue386_Op386SHRBconst_0(v)
+ return rewriteValue386_Op386SHRBconst(v)
case Op386SHRL:
- return rewriteValue386_Op386SHRL_0(v)
+ return rewriteValue386_Op386SHRL(v)
case Op386SHRLconst:
- return rewriteValue386_Op386SHRLconst_0(v)
+ return rewriteValue386_Op386SHRLconst(v)
case Op386SHRW:
- return rewriteValue386_Op386SHRW_0(v)
+ return rewriteValue386_Op386SHRW(v)
case Op386SHRWconst:
- return rewriteValue386_Op386SHRWconst_0(v)
+ return rewriteValue386_Op386SHRWconst(v)
case Op386SUBL:
- return rewriteValue386_Op386SUBL_0(v)
+ return rewriteValue386_Op386SUBL(v)
case Op386SUBLcarry:
- return rewriteValue386_Op386SUBLcarry_0(v)
+ return rewriteValue386_Op386SUBLcarry(v)
case Op386SUBLconst:
- return rewriteValue386_Op386SUBLconst_0(v)
+ return rewriteValue386_Op386SUBLconst(v)
case Op386SUBLload:
- return rewriteValue386_Op386SUBLload_0(v)
+ return rewriteValue386_Op386SUBLload(v)
case Op386SUBLloadidx4:
- return rewriteValue386_Op386SUBLloadidx4_0(v)
+ return rewriteValue386_Op386SUBLloadidx4(v)
case Op386SUBLmodify:
- return rewriteValue386_Op386SUBLmodify_0(v)
+ return rewriteValue386_Op386SUBLmodify(v)
case Op386SUBLmodifyidx4:
- return rewriteValue386_Op386SUBLmodifyidx4_0(v)
+ return rewriteValue386_Op386SUBLmodifyidx4(v)
case Op386SUBSD:
- return rewriteValue386_Op386SUBSD_0(v)
+ return rewriteValue386_Op386SUBSD(v)
case Op386SUBSDload:
- return rewriteValue386_Op386SUBSDload_0(v)
+ return rewriteValue386_Op386SUBSDload(v)
case Op386SUBSS:
- return rewriteValue386_Op386SUBSS_0(v)
+ return rewriteValue386_Op386SUBSS(v)
case Op386SUBSSload:
- return rewriteValue386_Op386SUBSSload_0(v)
+ return rewriteValue386_Op386SUBSSload(v)
case Op386XORL:
- return rewriteValue386_Op386XORL_0(v)
+ return rewriteValue386_Op386XORL(v)
case Op386XORLconst:
- return rewriteValue386_Op386XORLconst_0(v)
+ return rewriteValue386_Op386XORLconst(v)
case Op386XORLconstmodify:
- return rewriteValue386_Op386XORLconstmodify_0(v)
+ return rewriteValue386_Op386XORLconstmodify(v)
case Op386XORLconstmodifyidx4:
- return rewriteValue386_Op386XORLconstmodifyidx4_0(v)
+ return rewriteValue386_Op386XORLconstmodifyidx4(v)
case Op386XORLload:
- return rewriteValue386_Op386XORLload_0(v)
+ return rewriteValue386_Op386XORLload(v)
case Op386XORLloadidx4:
- return rewriteValue386_Op386XORLloadidx4_0(v)
+ return rewriteValue386_Op386XORLloadidx4(v)
case Op386XORLmodify:
- return rewriteValue386_Op386XORLmodify_0(v)
+ return rewriteValue386_Op386XORLmodify(v)
case Op386XORLmodifyidx4:
- return rewriteValue386_Op386XORLmodifyidx4_0(v)
+ return rewriteValue386_Op386XORLmodifyidx4(v)
case OpAdd16:
- return rewriteValue386_OpAdd16_0(v)
+ return rewriteValue386_OpAdd16(v)
case OpAdd32:
- return rewriteValue386_OpAdd32_0(v)
+ return rewriteValue386_OpAdd32(v)
case OpAdd32F:
- return rewriteValue386_OpAdd32F_0(v)
+ return rewriteValue386_OpAdd32F(v)
case OpAdd32carry:
- return rewriteValue386_OpAdd32carry_0(v)
+ return rewriteValue386_OpAdd32carry(v)
case OpAdd32withcarry:
- return rewriteValue386_OpAdd32withcarry_0(v)
+ return rewriteValue386_OpAdd32withcarry(v)
case OpAdd64F:
- return rewriteValue386_OpAdd64F_0(v)
+ return rewriteValue386_OpAdd64F(v)
case OpAdd8:
- return rewriteValue386_OpAdd8_0(v)
+ return rewriteValue386_OpAdd8(v)
case OpAddPtr:
- return rewriteValue386_OpAddPtr_0(v)
+ return rewriteValue386_OpAddPtr(v)
case OpAddr:
- return rewriteValue386_OpAddr_0(v)
+ return rewriteValue386_OpAddr(v)
case OpAnd16:
- return rewriteValue386_OpAnd16_0(v)
+ return rewriteValue386_OpAnd16(v)
case OpAnd32:
- return rewriteValue386_OpAnd32_0(v)
+ return rewriteValue386_OpAnd32(v)
case OpAnd8:
- return rewriteValue386_OpAnd8_0(v)
+ return rewriteValue386_OpAnd8(v)
case OpAndB:
- return rewriteValue386_OpAndB_0(v)
+ return rewriteValue386_OpAndB(v)
case OpAvg32u:
- return rewriteValue386_OpAvg32u_0(v)
+ return rewriteValue386_OpAvg32u(v)
case OpBswap32:
- return rewriteValue386_OpBswap32_0(v)
+ return rewriteValue386_OpBswap32(v)
case OpClosureCall:
- return rewriteValue386_OpClosureCall_0(v)
+ return rewriteValue386_OpClosureCall(v)
case OpCom16:
- return rewriteValue386_OpCom16_0(v)
+ return rewriteValue386_OpCom16(v)
case OpCom32:
- return rewriteValue386_OpCom32_0(v)
+ return rewriteValue386_OpCom32(v)
case OpCom8:
- return rewriteValue386_OpCom8_0(v)
+ return rewriteValue386_OpCom8(v)
case OpConst16:
- return rewriteValue386_OpConst16_0(v)
+ return rewriteValue386_OpConst16(v)
case OpConst32:
- return rewriteValue386_OpConst32_0(v)
+ return rewriteValue386_OpConst32(v)
case OpConst32F:
- return rewriteValue386_OpConst32F_0(v)
+ return rewriteValue386_OpConst32F(v)
case OpConst64F:
- return rewriteValue386_OpConst64F_0(v)
+ return rewriteValue386_OpConst64F(v)
case OpConst8:
- return rewriteValue386_OpConst8_0(v)
+ return rewriteValue386_OpConst8(v)
case OpConstBool:
- return rewriteValue386_OpConstBool_0(v)
+ return rewriteValue386_OpConstBool(v)
case OpConstNil:
- return rewriteValue386_OpConstNil_0(v)
+ return rewriteValue386_OpConstNil(v)
case OpCtz16:
- return rewriteValue386_OpCtz16_0(v)
+ return rewriteValue386_OpCtz16(v)
case OpCtz16NonZero:
- return rewriteValue386_OpCtz16NonZero_0(v)
+ return rewriteValue386_OpCtz16NonZero(v)
case OpCvt32Fto32:
- return rewriteValue386_OpCvt32Fto32_0(v)
+ return rewriteValue386_OpCvt32Fto32(v)
case OpCvt32Fto64F:
- return rewriteValue386_OpCvt32Fto64F_0(v)
+ return rewriteValue386_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValue386_OpCvt32to32F_0(v)
+ return rewriteValue386_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValue386_OpCvt32to64F_0(v)
+ return rewriteValue386_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValue386_OpCvt64Fto32_0(v)
+ return rewriteValue386_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValue386_OpCvt64Fto32F_0(v)
+ return rewriteValue386_OpCvt64Fto32F(v)
case OpDiv16:
- return rewriteValue386_OpDiv16_0(v)
+ return rewriteValue386_OpDiv16(v)
case OpDiv16u:
- return rewriteValue386_OpDiv16u_0(v)
+ return rewriteValue386_OpDiv16u(v)
case OpDiv32:
- return rewriteValue386_OpDiv32_0(v)
+ return rewriteValue386_OpDiv32(v)
case OpDiv32F:
- return rewriteValue386_OpDiv32F_0(v)
+ return rewriteValue386_OpDiv32F(v)
case OpDiv32u:
- return rewriteValue386_OpDiv32u_0(v)
+ return rewriteValue386_OpDiv32u(v)
case OpDiv64F:
- return rewriteValue386_OpDiv64F_0(v)
+ return rewriteValue386_OpDiv64F(v)
case OpDiv8:
- return rewriteValue386_OpDiv8_0(v)
+ return rewriteValue386_OpDiv8(v)
case OpDiv8u:
- return rewriteValue386_OpDiv8u_0(v)
+ return rewriteValue386_OpDiv8u(v)
case OpEq16:
- return rewriteValue386_OpEq16_0(v)
+ return rewriteValue386_OpEq16(v)
case OpEq32:
- return rewriteValue386_OpEq32_0(v)
+ return rewriteValue386_OpEq32(v)
case OpEq32F:
- return rewriteValue386_OpEq32F_0(v)
+ return rewriteValue386_OpEq32F(v)
case OpEq64F:
- return rewriteValue386_OpEq64F_0(v)
+ return rewriteValue386_OpEq64F(v)
case OpEq8:
- return rewriteValue386_OpEq8_0(v)
+ return rewriteValue386_OpEq8(v)
case OpEqB:
- return rewriteValue386_OpEqB_0(v)
+ return rewriteValue386_OpEqB(v)
case OpEqPtr:
- return rewriteValue386_OpEqPtr_0(v)
+ return rewriteValue386_OpEqPtr(v)
case OpGeq16:
- return rewriteValue386_OpGeq16_0(v)
+ return rewriteValue386_OpGeq16(v)
case OpGeq16U:
- return rewriteValue386_OpGeq16U_0(v)
+ return rewriteValue386_OpGeq16U(v)
case OpGeq32:
- return rewriteValue386_OpGeq32_0(v)
+ return rewriteValue386_OpGeq32(v)
case OpGeq32F:
- return rewriteValue386_OpGeq32F_0(v)
+ return rewriteValue386_OpGeq32F(v)
case OpGeq32U:
- return rewriteValue386_OpGeq32U_0(v)
+ return rewriteValue386_OpGeq32U(v)
case OpGeq64F:
- return rewriteValue386_OpGeq64F_0(v)
+ return rewriteValue386_OpGeq64F(v)
case OpGeq8:
- return rewriteValue386_OpGeq8_0(v)
+ return rewriteValue386_OpGeq8(v)
case OpGeq8U:
- return rewriteValue386_OpGeq8U_0(v)
+ return rewriteValue386_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValue386_OpGetCallerPC_0(v)
+ return rewriteValue386_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValue386_OpGetCallerSP_0(v)
+ return rewriteValue386_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValue386_OpGetClosurePtr_0(v)
+ return rewriteValue386_OpGetClosurePtr(v)
case OpGetG:
- return rewriteValue386_OpGetG_0(v)
+ return rewriteValue386_OpGetG(v)
case OpGreater16:
- return rewriteValue386_OpGreater16_0(v)
+ return rewriteValue386_OpGreater16(v)
case OpGreater16U:
- return rewriteValue386_OpGreater16U_0(v)
+ return rewriteValue386_OpGreater16U(v)
case OpGreater32:
- return rewriteValue386_OpGreater32_0(v)
+ return rewriteValue386_OpGreater32(v)
case OpGreater32F:
- return rewriteValue386_OpGreater32F_0(v)
+ return rewriteValue386_OpGreater32F(v)
case OpGreater32U:
- return rewriteValue386_OpGreater32U_0(v)
+ return rewriteValue386_OpGreater32U(v)
case OpGreater64F:
- return rewriteValue386_OpGreater64F_0(v)
+ return rewriteValue386_OpGreater64F(v)
case OpGreater8:
- return rewriteValue386_OpGreater8_0(v)
+ return rewriteValue386_OpGreater8(v)
case OpGreater8U:
- return rewriteValue386_OpGreater8U_0(v)
+ return rewriteValue386_OpGreater8U(v)
case OpHmul32:
- return rewriteValue386_OpHmul32_0(v)
+ return rewriteValue386_OpHmul32(v)
case OpHmul32u:
- return rewriteValue386_OpHmul32u_0(v)
+ return rewriteValue386_OpHmul32u(v)
case OpInterCall:
- return rewriteValue386_OpInterCall_0(v)
+ return rewriteValue386_OpInterCall(v)
case OpIsInBounds:
- return rewriteValue386_OpIsInBounds_0(v)
+ return rewriteValue386_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValue386_OpIsNonNil_0(v)
+ return rewriteValue386_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValue386_OpIsSliceInBounds_0(v)
+ return rewriteValue386_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValue386_OpLeq16_0(v)
+ return rewriteValue386_OpLeq16(v)
case OpLeq16U:
- return rewriteValue386_OpLeq16U_0(v)
+ return rewriteValue386_OpLeq16U(v)
case OpLeq32:
- return rewriteValue386_OpLeq32_0(v)
+ return rewriteValue386_OpLeq32(v)
case OpLeq32F:
- return rewriteValue386_OpLeq32F_0(v)
+ return rewriteValue386_OpLeq32F(v)
case OpLeq32U:
- return rewriteValue386_OpLeq32U_0(v)
+ return rewriteValue386_OpLeq32U(v)
case OpLeq64F:
- return rewriteValue386_OpLeq64F_0(v)
+ return rewriteValue386_OpLeq64F(v)
case OpLeq8:
- return rewriteValue386_OpLeq8_0(v)
+ return rewriteValue386_OpLeq8(v)
case OpLeq8U:
- return rewriteValue386_OpLeq8U_0(v)
+ return rewriteValue386_OpLeq8U(v)
case OpLess16:
- return rewriteValue386_OpLess16_0(v)
+ return rewriteValue386_OpLess16(v)
case OpLess16U:
- return rewriteValue386_OpLess16U_0(v)
+ return rewriteValue386_OpLess16U(v)
case OpLess32:
- return rewriteValue386_OpLess32_0(v)
+ return rewriteValue386_OpLess32(v)
case OpLess32F:
- return rewriteValue386_OpLess32F_0(v)
+ return rewriteValue386_OpLess32F(v)
case OpLess32U:
- return rewriteValue386_OpLess32U_0(v)
+ return rewriteValue386_OpLess32U(v)
case OpLess64F:
- return rewriteValue386_OpLess64F_0(v)
+ return rewriteValue386_OpLess64F(v)
case OpLess8:
- return rewriteValue386_OpLess8_0(v)
+ return rewriteValue386_OpLess8(v)
case OpLess8U:
- return rewriteValue386_OpLess8U_0(v)
+ return rewriteValue386_OpLess8U(v)
case OpLoad:
- return rewriteValue386_OpLoad_0(v)
+ return rewriteValue386_OpLoad(v)
case OpLocalAddr:
- return rewriteValue386_OpLocalAddr_0(v)
+ return rewriteValue386_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValue386_OpLsh16x16_0(v)
+ return rewriteValue386_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValue386_OpLsh16x32_0(v)
+ return rewriteValue386_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValue386_OpLsh16x64_0(v)
+ return rewriteValue386_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValue386_OpLsh16x8_0(v)
+ return rewriteValue386_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValue386_OpLsh32x16_0(v)
+ return rewriteValue386_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValue386_OpLsh32x32_0(v)
+ return rewriteValue386_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValue386_OpLsh32x64_0(v)
+ return rewriteValue386_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValue386_OpLsh32x8_0(v)
+ return rewriteValue386_OpLsh32x8(v)
case OpLsh8x16:
- return rewriteValue386_OpLsh8x16_0(v)
+ return rewriteValue386_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValue386_OpLsh8x32_0(v)
+ return rewriteValue386_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValue386_OpLsh8x64_0(v)
+ return rewriteValue386_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValue386_OpLsh8x8_0(v)
+ return rewriteValue386_OpLsh8x8(v)
case OpMod16:
- return rewriteValue386_OpMod16_0(v)
+ return rewriteValue386_OpMod16(v)
case OpMod16u:
- return rewriteValue386_OpMod16u_0(v)
+ return rewriteValue386_OpMod16u(v)
case OpMod32:
- return rewriteValue386_OpMod32_0(v)
+ return rewriteValue386_OpMod32(v)
case OpMod32u:
- return rewriteValue386_OpMod32u_0(v)
+ return rewriteValue386_OpMod32u(v)
case OpMod8:
- return rewriteValue386_OpMod8_0(v)
+ return rewriteValue386_OpMod8(v)
case OpMod8u:
- return rewriteValue386_OpMod8u_0(v)
+ return rewriteValue386_OpMod8u(v)
case OpMove:
- return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
+ return rewriteValue386_OpMove(v)
case OpMul16:
- return rewriteValue386_OpMul16_0(v)
+ return rewriteValue386_OpMul16(v)
case OpMul32:
- return rewriteValue386_OpMul32_0(v)
+ return rewriteValue386_OpMul32(v)
case OpMul32F:
- return rewriteValue386_OpMul32F_0(v)
+ return rewriteValue386_OpMul32F(v)
case OpMul32uhilo:
- return rewriteValue386_OpMul32uhilo_0(v)
+ return rewriteValue386_OpMul32uhilo(v)
case OpMul64F:
- return rewriteValue386_OpMul64F_0(v)
+ return rewriteValue386_OpMul64F(v)
case OpMul8:
- return rewriteValue386_OpMul8_0(v)
+ return rewriteValue386_OpMul8(v)
case OpNeg16:
- return rewriteValue386_OpNeg16_0(v)
+ return rewriteValue386_OpNeg16(v)
case OpNeg32:
- return rewriteValue386_OpNeg32_0(v)
+ return rewriteValue386_OpNeg32(v)
case OpNeg32F:
- return rewriteValue386_OpNeg32F_0(v)
+ return rewriteValue386_OpNeg32F(v)
case OpNeg64F:
- return rewriteValue386_OpNeg64F_0(v)
+ return rewriteValue386_OpNeg64F(v)
case OpNeg8:
- return rewriteValue386_OpNeg8_0(v)
+ return rewriteValue386_OpNeg8(v)
case OpNeq16:
- return rewriteValue386_OpNeq16_0(v)
+ return rewriteValue386_OpNeq16(v)
case OpNeq32:
- return rewriteValue386_OpNeq32_0(v)
+ return rewriteValue386_OpNeq32(v)
case OpNeq32F:
- return rewriteValue386_OpNeq32F_0(v)
+ return rewriteValue386_OpNeq32F(v)
case OpNeq64F:
- return rewriteValue386_OpNeq64F_0(v)
+ return rewriteValue386_OpNeq64F(v)
case OpNeq8:
- return rewriteValue386_OpNeq8_0(v)
+ return rewriteValue386_OpNeq8(v)
case OpNeqB:
- return rewriteValue386_OpNeqB_0(v)
+ return rewriteValue386_OpNeqB(v)
case OpNeqPtr:
- return rewriteValue386_OpNeqPtr_0(v)
+ return rewriteValue386_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValue386_OpNilCheck_0(v)
+ return rewriteValue386_OpNilCheck(v)
case OpNot:
- return rewriteValue386_OpNot_0(v)
+ return rewriteValue386_OpNot(v)
case OpOffPtr:
- return rewriteValue386_OpOffPtr_0(v)
+ return rewriteValue386_OpOffPtr(v)
case OpOr16:
- return rewriteValue386_OpOr16_0(v)
+ return rewriteValue386_OpOr16(v)
case OpOr32:
- return rewriteValue386_OpOr32_0(v)
+ return rewriteValue386_OpOr32(v)
case OpOr8:
- return rewriteValue386_OpOr8_0(v)
+ return rewriteValue386_OpOr8(v)
case OpOrB:
- return rewriteValue386_OpOrB_0(v)
+ return rewriteValue386_OpOrB(v)
case OpPanicBounds:
- return rewriteValue386_OpPanicBounds_0(v)
+ return rewriteValue386_OpPanicBounds(v)
case OpPanicExtend:
- return rewriteValue386_OpPanicExtend_0(v)
+ return rewriteValue386_OpPanicExtend(v)
case OpRotateLeft16:
- return rewriteValue386_OpRotateLeft16_0(v)
+ return rewriteValue386_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValue386_OpRotateLeft32_0(v)
+ return rewriteValue386_OpRotateLeft32(v)
case OpRotateLeft8:
- return rewriteValue386_OpRotateLeft8_0(v)
+ return rewriteValue386_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValue386_OpRound32F_0(v)
+ return rewriteValue386_OpRound32F(v)
case OpRound64F:
- return rewriteValue386_OpRound64F_0(v)
+ return rewriteValue386_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValue386_OpRsh16Ux16_0(v)
+ return rewriteValue386_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValue386_OpRsh16Ux32_0(v)
+ return rewriteValue386_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValue386_OpRsh16Ux64_0(v)
+ return rewriteValue386_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValue386_OpRsh16Ux8_0(v)
+ return rewriteValue386_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValue386_OpRsh16x16_0(v)
+ return rewriteValue386_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValue386_OpRsh16x32_0(v)
+ return rewriteValue386_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValue386_OpRsh16x64_0(v)
+ return rewriteValue386_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValue386_OpRsh16x8_0(v)
+ return rewriteValue386_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValue386_OpRsh32Ux16_0(v)
+ return rewriteValue386_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValue386_OpRsh32Ux32_0(v)
+ return rewriteValue386_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValue386_OpRsh32Ux64_0(v)
+ return rewriteValue386_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValue386_OpRsh32Ux8_0(v)
+ return rewriteValue386_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValue386_OpRsh32x16_0(v)
+ return rewriteValue386_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValue386_OpRsh32x32_0(v)
+ return rewriteValue386_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValue386_OpRsh32x64_0(v)
+ return rewriteValue386_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValue386_OpRsh32x8_0(v)
+ return rewriteValue386_OpRsh32x8(v)
case OpRsh8Ux16:
- return rewriteValue386_OpRsh8Ux16_0(v)
+ return rewriteValue386_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValue386_OpRsh8Ux32_0(v)
+ return rewriteValue386_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValue386_OpRsh8Ux64_0(v)
+ return rewriteValue386_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValue386_OpRsh8Ux8_0(v)
+ return rewriteValue386_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValue386_OpRsh8x16_0(v)
+ return rewriteValue386_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValue386_OpRsh8x32_0(v)
+ return rewriteValue386_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValue386_OpRsh8x64_0(v)
+ return rewriteValue386_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValue386_OpRsh8x8_0(v)
+ return rewriteValue386_OpRsh8x8(v)
case OpSelect0:
- return rewriteValue386_OpSelect0_0(v)
+ return rewriteValue386_OpSelect0(v)
case OpSelect1:
- return rewriteValue386_OpSelect1_0(v)
+ return rewriteValue386_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValue386_OpSignExt16to32_0(v)
+ return rewriteValue386_OpSignExt16to32(v)
case OpSignExt8to16:
- return rewriteValue386_OpSignExt8to16_0(v)
+ return rewriteValue386_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValue386_OpSignExt8to32_0(v)
+ return rewriteValue386_OpSignExt8to32(v)
case OpSignmask:
- return rewriteValue386_OpSignmask_0(v)
+ return rewriteValue386_OpSignmask(v)
case OpSlicemask:
- return rewriteValue386_OpSlicemask_0(v)
+ return rewriteValue386_OpSlicemask(v)
case OpSqrt:
- return rewriteValue386_OpSqrt_0(v)
+ return rewriteValue386_OpSqrt(v)
case OpStaticCall:
- return rewriteValue386_OpStaticCall_0(v)
+ return rewriteValue386_OpStaticCall(v)
case OpStore:
- return rewriteValue386_OpStore_0(v)
+ return rewriteValue386_OpStore(v)
case OpSub16:
- return rewriteValue386_OpSub16_0(v)
+ return rewriteValue386_OpSub16(v)
case OpSub32:
- return rewriteValue386_OpSub32_0(v)
+ return rewriteValue386_OpSub32(v)
case OpSub32F:
- return rewriteValue386_OpSub32F_0(v)
+ return rewriteValue386_OpSub32F(v)
case OpSub32carry:
- return rewriteValue386_OpSub32carry_0(v)
+ return rewriteValue386_OpSub32carry(v)
case OpSub32withcarry:
- return rewriteValue386_OpSub32withcarry_0(v)
+ return rewriteValue386_OpSub32withcarry(v)
case OpSub64F:
- return rewriteValue386_OpSub64F_0(v)
+ return rewriteValue386_OpSub64F(v)
case OpSub8:
- return rewriteValue386_OpSub8_0(v)
+ return rewriteValue386_OpSub8(v)
case OpSubPtr:
- return rewriteValue386_OpSubPtr_0(v)
+ return rewriteValue386_OpSubPtr(v)
case OpTrunc16to8:
- return rewriteValue386_OpTrunc16to8_0(v)
+ return rewriteValue386_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValue386_OpTrunc32to16_0(v)
+ return rewriteValue386_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValue386_OpTrunc32to8_0(v)
+ return rewriteValue386_OpTrunc32to8(v)
case OpWB:
- return rewriteValue386_OpWB_0(v)
+ return rewriteValue386_OpWB(v)
case OpXor16:
- return rewriteValue386_OpXor16_0(v)
+ return rewriteValue386_OpXor16(v)
case OpXor32:
- return rewriteValue386_OpXor32_0(v)
+ return rewriteValue386_OpXor32(v)
case OpXor8:
- return rewriteValue386_OpXor8_0(v)
+ return rewriteValue386_OpXor8(v)
case OpZero:
- return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
+ return rewriteValue386_OpZero(v)
case OpZeroExt16to32:
- return rewriteValue386_OpZeroExt16to32_0(v)
+ return rewriteValue386_OpZeroExt16to32(v)
case OpZeroExt8to16:
- return rewriteValue386_OpZeroExt8to16_0(v)
+ return rewriteValue386_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValue386_OpZeroExt8to32_0(v)
+ return rewriteValue386_OpZeroExt8to32(v)
case OpZeromask:
- return rewriteValue386_OpZeromask_0(v)
+ return rewriteValue386_OpZeromask(v)
}
return false
}
-func rewriteValue386_Op386ADCL_0(v *Value) bool {
+func rewriteValue386_Op386ADCL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -731,7 +731,7 @@
}
return false
}
-func rewriteValue386_Op386ADDL_0(v *Value) bool {
+func rewriteValue386_Op386ADDL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDL x (MOVLconst [c]))
@@ -933,11 +933,6 @@
}
break
}
- return false
-}
-func rewriteValue386_Op386ADDL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (ADDL x (LEAL [c] {s} y))
// cond: x.Op != OpSB && y.Op != OpSB
// result: (LEAL1 [c] {s} x y)
@@ -1036,7 +1031,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
+func rewriteValue386_Op386ADDLcarry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDLcarry x (MOVLconst [c]))
@@ -1057,7 +1052,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
+func rewriteValue386_Op386ADDLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDLconst [c] (ADDL x y))
// result: (LEAL1 [c] x y)
@@ -1224,7 +1219,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconstmodify_0(v *Value) bool {
+func rewriteValue386_Op386ADDLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1276,7 +1271,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLconstmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ADDLconstmodifyidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1357,7 +1352,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLload_0(v *Value) bool {
+func rewriteValue386_Op386ADDLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1441,7 +1436,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386ADDLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1529,7 +1524,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLmodify_0(v *Value) bool {
+func rewriteValue386_Op386ADDLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1586,7 +1581,7 @@
}
return false
}
-func rewriteValue386_Op386ADDLmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ADDLmodifyidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1698,7 +1693,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSD_0(v *Value) bool {
+func rewriteValue386_Op386ADDSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1732,7 +1727,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSDload_0(v *Value) bool {
+func rewriteValue386_Op386ADDSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1789,7 +1784,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSS_0(v *Value) bool {
+func rewriteValue386_Op386ADDSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1823,7 +1818,7 @@
}
return false
}
-func rewriteValue386_Op386ADDSSload_0(v *Value) bool {
+func rewriteValue386_Op386ADDSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1880,7 +1875,7 @@
}
return false
}
-func rewriteValue386_Op386ANDL_0(v *Value) bool {
+func rewriteValue386_Op386ANDL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDL x (MOVLconst [c]))
@@ -1969,7 +1964,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
+func rewriteValue386_Op386ANDLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDLconst [c] (ANDLconst [d] x))
// result: (ANDLconst [c & d] x)
@@ -2025,7 +2020,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconstmodify_0(v *Value) bool {
+func rewriteValue386_Op386ANDLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2077,7 +2072,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLconstmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ANDLconstmodifyidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2158,7 +2153,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLload_0(v *Value) bool {
+func rewriteValue386_Op386ANDLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2242,7 +2237,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386ANDLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -2330,7 +2325,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLmodify_0(v *Value) bool {
+func rewriteValue386_Op386ANDLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2387,7 +2382,7 @@
}
return false
}
-func rewriteValue386_Op386ANDLmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ANDLmodifyidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -2499,7 +2494,7 @@
}
return false
}
-func rewriteValue386_Op386CMPB_0(v *Value) bool {
+func rewriteValue386_Op386CMPB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2583,7 +2578,7 @@
}
return false
}
-func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
+func rewriteValue386_Op386CMPBconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPBconst (MOVLconst [x]) [y])
@@ -2758,7 +2753,7 @@
}
return false
}
-func rewriteValue386_Op386CMPBload_0(v *Value) bool {
+func rewriteValue386_Op386CMPBload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2786,7 +2781,7 @@
}
return false
}
-func rewriteValue386_Op386CMPL_0(v *Value) bool {
+func rewriteValue386_Op386CMPL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2870,8 +2865,9 @@
}
return false
}
-func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
+func rewriteValue386_Op386CMPLconst(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -3031,11 +3027,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValue386_Op386CMPLconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (CMPLconst l:(MOVLload {sym} [off] ptr mem) [c])
// cond: l.Uses == 1 && validValAndOff(c, off) && clobber(l)
// result: @l.Block (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
@@ -3064,7 +3055,7 @@
}
return false
}
-func rewriteValue386_Op386CMPLload_0(v *Value) bool {
+func rewriteValue386_Op386CMPLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3092,7 +3083,7 @@
}
return false
}
-func rewriteValue386_Op386CMPW_0(v *Value) bool {
+func rewriteValue386_Op386CMPW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3176,7 +3167,7 @@
}
return false
}
-func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
+func rewriteValue386_Op386CMPWconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPWconst (MOVLconst [x]) [y])
@@ -3351,7 +3342,7 @@
}
return false
}
-func rewriteValue386_Op386CMPWload_0(v *Value) bool {
+func rewriteValue386_Op386CMPWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3379,7 +3370,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSD_0(v *Value) bool {
+func rewriteValue386_Op386DIVSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3410,7 +3401,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSDload_0(v *Value) bool {
+func rewriteValue386_Op386DIVSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3467,7 +3458,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSS_0(v *Value) bool {
+func rewriteValue386_Op386DIVSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3498,7 +3489,7 @@
}
return false
}
-func rewriteValue386_Op386DIVSSload_0(v *Value) bool {
+func rewriteValue386_Op386DIVSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3555,7 +3546,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL_0(v *Value) bool {
+func rewriteValue386_Op386LEAL(v *Value) bool {
v_0 := v.Args[0]
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
@@ -3719,7 +3710,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL1_0(v *Value) bool {
+func rewriteValue386_Op386LEAL1(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
@@ -3835,7 +3826,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL2_0(v *Value) bool {
+func rewriteValue386_Op386LEAL2(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
@@ -3941,7 +3932,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL4_0(v *Value) bool {
+func rewriteValue386_Op386LEAL4(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
@@ -4030,7 +4021,7 @@
}
return false
}
-func rewriteValue386_Op386LEAL8_0(v *Value) bool {
+func rewriteValue386_Op386LEAL8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
@@ -4102,7 +4093,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
+func rewriteValue386_Op386MOVBLSX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
@@ -4149,7 +4140,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
+func rewriteValue386_Op386MOVBLSXload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4201,7 +4192,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
+func rewriteValue386_Op386MOVBLZX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
@@ -4271,7 +4262,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBload_0(v *Value) bool {
+func rewriteValue386_Op386MOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4412,7 +4403,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVBloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4464,7 +4455,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
+func rewriteValue386_Op386MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4719,12 +4710,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValue386_Op386MOVBstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVBstore [i] {s} p w x:(MOVBstore {s} [i+1] p (SHRLconst [8] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstore [i] {s} p w mem)
@@ -4787,7 +4772,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4935,7 +4920,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5009,7 +4994,7 @@
}
return false
}
-func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -5253,7 +5238,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLload_0(v *Value) bool {
+func rewriteValue386_Op386MOVLload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5420,7 +5405,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5494,7 +5479,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5540,7 +5525,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5798,12 +5783,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValue386_Op386MOVLstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVLstore {sym} [off] ptr y:(ADDL l:(MOVLload [off] {sym} ptr mem) x) mem)
// cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l)
// result: (ADDLmodify [off] {sym} ptr x mem)
@@ -6090,7 +6069,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6211,7 +6190,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6276,7 +6255,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6322,7 +6301,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6403,7 +6382,7 @@
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6703,13 +6682,6 @@
}
break
}
- return false
-}
-func rewriteValue386_Op386MOVLstoreidx4_10(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVLstoreidx4 {sym} [off] ptr idx y:(XORL l:(MOVLloadidx4 [off] {sym} ptr idx mem) x) mem)
// cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l)
// result: (XORLmodifyidx4 [off] {sym} ptr idx x mem)
@@ -6867,7 +6839,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDconst(v *Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -6887,7 +6859,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7018,7 +6990,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7064,7 +7036,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7110,7 +7082,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7252,7 +7224,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7303,7 +7275,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7354,7 +7326,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSconst(v *Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -7374,7 +7346,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7505,7 +7477,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7551,7 +7523,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7597,7 +7569,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7739,7 +7711,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7790,7 +7762,7 @@
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7841,7 +7813,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
+func rewriteValue386_Op386MOVWLSX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
@@ -7888,7 +7860,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
+func rewriteValue386_Op386MOVWLSXload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7940,7 +7912,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
+func rewriteValue386_Op386MOVWLZX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
@@ -8037,7 +8009,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWload_0(v *Value) bool {
+func rewriteValue386_Op386MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8203,7 +8175,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8277,7 +8249,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8323,7 +8295,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8584,7 +8556,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8757,7 +8729,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8850,7 +8822,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8928,7 +8900,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9086,7 +9058,7 @@
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9207,7 +9179,7 @@
}
return false
}
-func rewriteValue386_Op386MULL_0(v *Value) bool {
+func rewriteValue386_Op386MULL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULL x (MOVLconst [c]))
@@ -9284,7 +9256,7 @@
}
return false
}
-func rewriteValue386_Op386MULLconst_0(v *Value) bool {
+func rewriteValue386_Op386MULLconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLconst [c] (MULLconst [d] x))
@@ -9415,11 +9387,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValue386_Op386MULLconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULLconst [9] x)
// result: (LEAL8 x x)
for {
@@ -9573,11 +9540,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValue386_Op386MULLconst_20(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULLconst [73] x)
// result: (LEAL8 x (LEAL8 <v.Type> x x))
for {
@@ -9747,10 +9709,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValue386_Op386MULLconst_30(v *Value) bool {
- v_0 := v.Args[0]
// match: (MULLconst [c] (MOVLconst [d]))
// result: (MOVLconst [int64(int32(c*d))])
for {
@@ -9765,7 +9723,7 @@
}
return false
}
-func rewriteValue386_Op386MULLload_0(v *Value) bool {
+func rewriteValue386_Op386MULLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9849,7 +9807,7 @@
}
return false
}
-func rewriteValue386_Op386MULLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386MULLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9937,7 +9895,7 @@
}
return false
}
-func rewriteValue386_Op386MULSD_0(v *Value) bool {
+func rewriteValue386_Op386MULSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9971,7 +9929,7 @@
}
return false
}
-func rewriteValue386_Op386MULSDload_0(v *Value) bool {
+func rewriteValue386_Op386MULSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10028,7 +9986,7 @@
}
return false
}
-func rewriteValue386_Op386MULSS_0(v *Value) bool {
+func rewriteValue386_Op386MULSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10062,7 +10020,7 @@
}
return false
}
-func rewriteValue386_Op386MULSSload_0(v *Value) bool {
+func rewriteValue386_Op386MULSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10119,7 +10077,7 @@
}
return false
}
-func rewriteValue386_Op386NEGL_0(v *Value) bool {
+func rewriteValue386_Op386NEGL(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGL (MOVLconst [c]))
// result: (MOVLconst [int64(int32(-c))])
@@ -10134,7 +10092,7 @@
}
return false
}
-func rewriteValue386_Op386NOTL_0(v *Value) bool {
+func rewriteValue386_Op386NOTL(v *Value) bool {
v_0 := v.Args[0]
// match: (NOTL (MOVLconst [c]))
// result: (MOVLconst [^c])
@@ -10149,7 +10107,7 @@
}
return false
}
-func rewriteValue386_Op386ORL_0(v *Value) bool {
+func rewriteValue386_Op386ORL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10470,12 +10428,6 @@
}
break
}
- return false
-}
-func rewriteValue386_Op386ORL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (ORL o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx 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)
@@ -10558,7 +10510,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconst_0(v *Value) bool {
+func rewriteValue386_Op386ORLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORLconst [c] x)
// cond: int32(c)==0
@@ -10600,7 +10552,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconstmodify_0(v *Value) bool {
+func rewriteValue386_Op386ORLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10652,7 +10604,7 @@
}
return false
}
-func rewriteValue386_Op386ORLconstmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ORLconstmodifyidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10733,7 +10685,7 @@
}
return false
}
-func rewriteValue386_Op386ORLload_0(v *Value) bool {
+func rewriteValue386_Op386ORLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10817,7 +10769,7 @@
}
return false
}
-func rewriteValue386_Op386ORLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386ORLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10905,7 +10857,7 @@
}
return false
}
-func rewriteValue386_Op386ORLmodify_0(v *Value) bool {
+func rewriteValue386_Op386ORLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10962,7 +10914,7 @@
}
return false
}
-func rewriteValue386_Op386ORLmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386ORLmodifyidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11074,7 +11026,7 @@
}
return false
}
-func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
+func rewriteValue386_Op386ROLBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLBconst [c] (ROLBconst [d] x))
// result: (ROLBconst [(c+d)& 7] x)
@@ -11104,7 +11056,7 @@
}
return false
}
-func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
+func rewriteValue386_Op386ROLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLLconst [c] (ROLLconst [d] x))
// result: (ROLLconst [(c+d)&31] x)
@@ -11134,7 +11086,7 @@
}
return false
}
-func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
+func rewriteValue386_Op386ROLWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLWconst [c] (ROLWconst [d] x))
// result: (ROLWconst [(c+d)&15] x)
@@ -11164,7 +11116,7 @@
}
return false
}
-func rewriteValue386_Op386SARB_0(v *Value) bool {
+func rewriteValue386_Op386SARB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARB x (MOVLconst [c]))
@@ -11182,7 +11134,7 @@
}
return false
}
-func rewriteValue386_Op386SARBconst_0(v *Value) bool {
+func rewriteValue386_Op386SARBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARBconst x [0])
// result: x
@@ -11210,7 +11162,7 @@
}
return false
}
-func rewriteValue386_Op386SARL_0(v *Value) bool {
+func rewriteValue386_Op386SARL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARL x (MOVLconst [c]))
@@ -11241,7 +11193,7 @@
}
return false
}
-func rewriteValue386_Op386SARLconst_0(v *Value) bool {
+func rewriteValue386_Op386SARLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARLconst x [0])
// result: x
@@ -11269,7 +11221,7 @@
}
return false
}
-func rewriteValue386_Op386SARW_0(v *Value) bool {
+func rewriteValue386_Op386SARW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARW x (MOVLconst [c]))
@@ -11287,7 +11239,7 @@
}
return false
}
-func rewriteValue386_Op386SARWconst_0(v *Value) bool {
+func rewriteValue386_Op386SARWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARWconst x [0])
// result: x
@@ -11315,7 +11267,7 @@
}
return false
}
-func rewriteValue386_Op386SBBL_0(v *Value) bool {
+func rewriteValue386_Op386SBBL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11336,7 +11288,7 @@
}
return false
}
-func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
+func rewriteValue386_Op386SBBLcarrymask(v *Value) bool {
v_0 := v.Args[0]
// match: (SBBLcarrymask (FlagEQ))
// result: (MOVLconst [0])
@@ -11390,7 +11342,7 @@
}
return false
}
-func rewriteValue386_Op386SETA_0(v *Value) bool {
+func rewriteValue386_Op386SETA(v *Value) bool {
v_0 := v.Args[0]
// match: (SETA (InvertFlags x))
// result: (SETB x)
@@ -11455,7 +11407,7 @@
}
return false
}
-func rewriteValue386_Op386SETAE_0(v *Value) bool {
+func rewriteValue386_Op386SETAE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETAE (InvertFlags x))
// result: (SETBE x)
@@ -11520,7 +11472,7 @@
}
return false
}
-func rewriteValue386_Op386SETB_0(v *Value) bool {
+func rewriteValue386_Op386SETB(v *Value) bool {
v_0 := v.Args[0]
// match: (SETB (InvertFlags x))
// result: (SETA x)
@@ -11585,7 +11537,7 @@
}
return false
}
-func rewriteValue386_Op386SETBE_0(v *Value) bool {
+func rewriteValue386_Op386SETBE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETBE (InvertFlags x))
// result: (SETAE x)
@@ -11650,7 +11602,7 @@
}
return false
}
-func rewriteValue386_Op386SETEQ_0(v *Value) bool {
+func rewriteValue386_Op386SETEQ(v *Value) bool {
v_0 := v.Args[0]
// match: (SETEQ (InvertFlags x))
// result: (SETEQ x)
@@ -11715,7 +11667,7 @@
}
return false
}
-func rewriteValue386_Op386SETG_0(v *Value) bool {
+func rewriteValue386_Op386SETG(v *Value) bool {
v_0 := v.Args[0]
// match: (SETG (InvertFlags x))
// result: (SETL x)
@@ -11780,7 +11732,7 @@
}
return false
}
-func rewriteValue386_Op386SETGE_0(v *Value) bool {
+func rewriteValue386_Op386SETGE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETGE (InvertFlags x))
// result: (SETLE x)
@@ -11845,7 +11797,7 @@
}
return false
}
-func rewriteValue386_Op386SETL_0(v *Value) bool {
+func rewriteValue386_Op386SETL(v *Value) bool {
v_0 := v.Args[0]
// match: (SETL (InvertFlags x))
// result: (SETG x)
@@ -11910,7 +11862,7 @@
}
return false
}
-func rewriteValue386_Op386SETLE_0(v *Value) bool {
+func rewriteValue386_Op386SETLE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETLE (InvertFlags x))
// result: (SETGE x)
@@ -11975,7 +11927,7 @@
}
return false
}
-func rewriteValue386_Op386SETNE_0(v *Value) bool {
+func rewriteValue386_Op386SETNE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETNE (InvertFlags x))
// result: (SETNE x)
@@ -12040,7 +11992,7 @@
}
return false
}
-func rewriteValue386_Op386SHLL_0(v *Value) bool {
+func rewriteValue386_Op386SHLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHLL x (MOVLconst [c]))
@@ -12071,7 +12023,7 @@
}
return false
}
-func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
+func rewriteValue386_Op386SHLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHLLconst x [0])
// result: x
@@ -12087,7 +12039,7 @@
}
return false
}
-func rewriteValue386_Op386SHRB_0(v *Value) bool {
+func rewriteValue386_Op386SHRB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRB x (MOVLconst [c]))
@@ -12124,7 +12076,7 @@
}
return false
}
-func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
+func rewriteValue386_Op386SHRBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRBconst x [0])
// result: x
@@ -12140,7 +12092,7 @@
}
return false
}
-func rewriteValue386_Op386SHRL_0(v *Value) bool {
+func rewriteValue386_Op386SHRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRL x (MOVLconst [c]))
@@ -12171,7 +12123,7 @@
}
return false
}
-func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
+func rewriteValue386_Op386SHRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRLconst x [0])
// result: x
@@ -12187,7 +12139,7 @@
}
return false
}
-func rewriteValue386_Op386SHRW_0(v *Value) bool {
+func rewriteValue386_Op386SHRW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRW x (MOVLconst [c]))
@@ -12224,7 +12176,7 @@
}
return false
}
-func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
+func rewriteValue386_Op386SHRWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRWconst x [0])
// result: x
@@ -12240,7 +12192,7 @@
}
return false
}
-func rewriteValue386_Op386SUBL_0(v *Value) bool {
+func rewriteValue386_Op386SUBL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12335,7 +12287,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
+func rewriteValue386_Op386SUBLcarry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBLcarry x (MOVLconst [c]))
@@ -12353,7 +12305,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
+func rewriteValue386_Op386SUBLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
@@ -12380,7 +12332,7 @@
return true
}
}
-func rewriteValue386_Op386SUBLload_0(v *Value) bool {
+func rewriteValue386_Op386SUBLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12464,7 +12416,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386SUBLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12552,7 +12504,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLmodify_0(v *Value) bool {
+func rewriteValue386_Op386SUBLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12609,7 +12561,7 @@
}
return false
}
-func rewriteValue386_Op386SUBLmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386SUBLmodifyidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12721,7 +12673,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSD_0(v *Value) bool {
+func rewriteValue386_Op386SUBSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12752,7 +12704,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSDload_0(v *Value) bool {
+func rewriteValue386_Op386SUBSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12809,7 +12761,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSS_0(v *Value) bool {
+func rewriteValue386_Op386SUBSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12840,7 +12792,7 @@
}
return false
}
-func rewriteValue386_Op386SUBSSload_0(v *Value) bool {
+func rewriteValue386_Op386SUBSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12897,7 +12849,7 @@
}
return false
}
-func rewriteValue386_Op386XORL_0(v *Value) bool {
+func rewriteValue386_Op386XORL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORL x (MOVLconst [c]))
@@ -13059,7 +13011,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconst_0(v *Value) bool {
+func rewriteValue386_Op386XORLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORLconst [c] (XORLconst [d] x))
// result: (XORLconst [c ^ d] x)
@@ -13103,7 +13055,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconstmodify_0(v *Value) bool {
+func rewriteValue386_Op386XORLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13155,7 +13107,7 @@
}
return false
}
-func rewriteValue386_Op386XORLconstmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386XORLconstmodifyidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13236,7 +13188,7 @@
}
return false
}
-func rewriteValue386_Op386XORLload_0(v *Value) bool {
+func rewriteValue386_Op386XORLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13320,7 +13272,7 @@
}
return false
}
-func rewriteValue386_Op386XORLloadidx4_0(v *Value) bool {
+func rewriteValue386_Op386XORLloadidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13408,7 +13360,7 @@
}
return false
}
-func rewriteValue386_Op386XORLmodify_0(v *Value) bool {
+func rewriteValue386_Op386XORLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13465,7 +13417,7 @@
}
return false
}
-func rewriteValue386_Op386XORLmodifyidx4_0(v *Value) bool {
+func rewriteValue386_Op386XORLmodifyidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -13577,7 +13529,7 @@
}
return false
}
-func rewriteValue386_OpAdd16_0(v *Value) bool {
+func rewriteValue386_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -13591,7 +13543,7 @@
return true
}
}
-func rewriteValue386_OpAdd32_0(v *Value) bool {
+func rewriteValue386_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -13605,7 +13557,7 @@
return true
}
}
-func rewriteValue386_OpAdd32F_0(v *Value) bool {
+func rewriteValue386_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -13619,7 +13571,7 @@
return true
}
}
-func rewriteValue386_OpAdd32carry_0(v *Value) bool {
+func rewriteValue386_OpAdd32carry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32carry x y)
@@ -13633,7 +13585,7 @@
return true
}
}
-func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
+func rewriteValue386_OpAdd32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13650,7 +13602,7 @@
return true
}
}
-func rewriteValue386_OpAdd64F_0(v *Value) bool {
+func rewriteValue386_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -13664,7 +13616,7 @@
return true
}
}
-func rewriteValue386_OpAdd8_0(v *Value) bool {
+func rewriteValue386_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -13678,7 +13630,7 @@
return true
}
}
-func rewriteValue386_OpAddPtr_0(v *Value) bool {
+func rewriteValue386_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -13692,7 +13644,7 @@
return true
}
}
-func rewriteValue386_OpAddr_0(v *Value) bool {
+func rewriteValue386_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (LEAL {sym} base)
@@ -13705,7 +13657,7 @@
return true
}
}
-func rewriteValue386_OpAnd16_0(v *Value) bool {
+func rewriteValue386_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -13719,7 +13671,7 @@
return true
}
}
-func rewriteValue386_OpAnd32_0(v *Value) bool {
+func rewriteValue386_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -13733,7 +13685,7 @@
return true
}
}
-func rewriteValue386_OpAnd8_0(v *Value) bool {
+func rewriteValue386_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -13747,7 +13699,7 @@
return true
}
}
-func rewriteValue386_OpAndB_0(v *Value) bool {
+func rewriteValue386_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -13761,7 +13713,7 @@
return true
}
}
-func rewriteValue386_OpAvg32u_0(v *Value) bool {
+func rewriteValue386_OpAvg32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Avg32u x y)
@@ -13775,7 +13727,7 @@
return true
}
}
-func rewriteValue386_OpBswap32_0(v *Value) bool {
+func rewriteValue386_OpBswap32(v *Value) bool {
v_0 := v.Args[0]
// match: (Bswap32 x)
// result: (BSWAPL x)
@@ -13786,7 +13738,7 @@
return true
}
}
-func rewriteValue386_OpClosureCall_0(v *Value) bool {
+func rewriteValue386_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13805,7 +13757,7 @@
return true
}
}
-func rewriteValue386_OpCom16_0(v *Value) bool {
+func rewriteValue386_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (NOTL x)
@@ -13816,7 +13768,7 @@
return true
}
}
-func rewriteValue386_OpCom32_0(v *Value) bool {
+func rewriteValue386_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (NOTL x)
@@ -13827,7 +13779,7 @@
return true
}
}
-func rewriteValue386_OpCom8_0(v *Value) bool {
+func rewriteValue386_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (NOTL x)
@@ -13838,7 +13790,7 @@
return true
}
}
-func rewriteValue386_OpConst16_0(v *Value) bool {
+func rewriteValue386_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVLconst [val])
for {
@@ -13848,7 +13800,7 @@
return true
}
}
-func rewriteValue386_OpConst32_0(v *Value) bool {
+func rewriteValue386_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVLconst [val])
for {
@@ -13858,7 +13810,7 @@
return true
}
}
-func rewriteValue386_OpConst32F_0(v *Value) bool {
+func rewriteValue386_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (MOVSSconst [val])
for {
@@ -13868,7 +13820,7 @@
return true
}
}
-func rewriteValue386_OpConst64F_0(v *Value) bool {
+func rewriteValue386_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (MOVSDconst [val])
for {
@@ -13878,7 +13830,7 @@
return true
}
}
-func rewriteValue386_OpConst8_0(v *Value) bool {
+func rewriteValue386_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVLconst [val])
for {
@@ -13888,7 +13840,7 @@
return true
}
}
-func rewriteValue386_OpConstBool_0(v *Value) bool {
+func rewriteValue386_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVLconst [b])
for {
@@ -13898,7 +13850,7 @@
return true
}
}
-func rewriteValue386_OpConstNil_0(v *Value) bool {
+func rewriteValue386_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVLconst [0])
for {
@@ -13907,7 +13859,7 @@
return true
}
}
-func rewriteValue386_OpCtz16_0(v *Value) bool {
+func rewriteValue386_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -13923,7 +13875,7 @@
return true
}
}
-func rewriteValue386_OpCtz16NonZero_0(v *Value) bool {
+func rewriteValue386_OpCtz16NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz16NonZero x)
// result: (BSFL x)
@@ -13934,7 +13886,7 @@
return true
}
}
-func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValue386_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (CVTTSS2SL x)
@@ -13945,7 +13897,7 @@
return true
}
}
-func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValue386_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (CVTSS2SD x)
@@ -13956,7 +13908,7 @@
return true
}
}
-func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
+func rewriteValue386_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (CVTSL2SS x)
@@ -13967,7 +13919,7 @@
return true
}
}
-func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
+func rewriteValue386_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (CVTSL2SD x)
@@ -13978,7 +13930,7 @@
return true
}
}
-func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (CVTTSD2SL x)
@@ -13989,7 +13941,7 @@
return true
}
}
-func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (CVTSD2SS x)
@@ -14000,7 +13952,7 @@
return true
}
}
-func rewriteValue386_OpDiv16_0(v *Value) bool {
+func rewriteValue386_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div16 [a] x y)
@@ -14016,7 +13968,7 @@
return true
}
}
-func rewriteValue386_OpDiv16u_0(v *Value) bool {
+func rewriteValue386_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div16u x y)
@@ -14030,7 +13982,7 @@
return true
}
}
-func rewriteValue386_OpDiv32_0(v *Value) bool {
+func rewriteValue386_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 [a] x y)
@@ -14046,7 +13998,7 @@
return true
}
}
-func rewriteValue386_OpDiv32F_0(v *Value) bool {
+func rewriteValue386_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -14060,7 +14012,7 @@
return true
}
}
-func rewriteValue386_OpDiv32u_0(v *Value) bool {
+func rewriteValue386_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32u x y)
@@ -14074,7 +14026,7 @@
return true
}
}
-func rewriteValue386_OpDiv64F_0(v *Value) bool {
+func rewriteValue386_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -14088,7 +14040,7 @@
return true
}
}
-func rewriteValue386_OpDiv8_0(v *Value) bool {
+func rewriteValue386_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14108,7 +14060,7 @@
return true
}
}
-func rewriteValue386_OpDiv8u_0(v *Value) bool {
+func rewriteValue386_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14128,7 +14080,7 @@
return true
}
}
-func rewriteValue386_OpEq16_0(v *Value) bool {
+func rewriteValue386_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14145,7 +14097,7 @@
return true
}
}
-func rewriteValue386_OpEq32_0(v *Value) bool {
+func rewriteValue386_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14162,7 +14114,7 @@
return true
}
}
-func rewriteValue386_OpEq32F_0(v *Value) bool {
+func rewriteValue386_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14179,7 +14131,7 @@
return true
}
}
-func rewriteValue386_OpEq64F_0(v *Value) bool {
+func rewriteValue386_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14196,7 +14148,7 @@
return true
}
}
-func rewriteValue386_OpEq8_0(v *Value) bool {
+func rewriteValue386_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14213,7 +14165,7 @@
return true
}
}
-func rewriteValue386_OpEqB_0(v *Value) bool {
+func rewriteValue386_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14230,7 +14182,7 @@
return true
}
}
-func rewriteValue386_OpEqPtr_0(v *Value) bool {
+func rewriteValue386_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14247,7 +14199,7 @@
return true
}
}
-func rewriteValue386_OpGeq16_0(v *Value) bool {
+func rewriteValue386_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14264,7 +14216,7 @@
return true
}
}
-func rewriteValue386_OpGeq16U_0(v *Value) bool {
+func rewriteValue386_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14281,7 +14233,7 @@
return true
}
}
-func rewriteValue386_OpGeq32_0(v *Value) bool {
+func rewriteValue386_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14298,7 +14250,7 @@
return true
}
}
-func rewriteValue386_OpGeq32F_0(v *Value) bool {
+func rewriteValue386_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14315,7 +14267,7 @@
return true
}
}
-func rewriteValue386_OpGeq32U_0(v *Value) bool {
+func rewriteValue386_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14332,7 +14284,7 @@
return true
}
}
-func rewriteValue386_OpGeq64F_0(v *Value) bool {
+func rewriteValue386_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14349,7 +14301,7 @@
return true
}
}
-func rewriteValue386_OpGeq8_0(v *Value) bool {
+func rewriteValue386_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14366,7 +14318,7 @@
return true
}
}
-func rewriteValue386_OpGeq8U_0(v *Value) bool {
+func rewriteValue386_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14383,7 +14335,7 @@
return true
}
}
-func rewriteValue386_OpGetCallerPC_0(v *Value) bool {
+func rewriteValue386_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -14391,7 +14343,7 @@
return true
}
}
-func rewriteValue386_OpGetCallerSP_0(v *Value) bool {
+func rewriteValue386_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -14399,7 +14351,7 @@
return true
}
}
-func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValue386_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -14407,7 +14359,7 @@
return true
}
}
-func rewriteValue386_OpGetG_0(v *Value) bool {
+func rewriteValue386_OpGetG(v *Value) bool {
v_0 := v.Args[0]
// match: (GetG mem)
// result: (LoweredGetG mem)
@@ -14418,7 +14370,7 @@
return true
}
}
-func rewriteValue386_OpGreater16_0(v *Value) bool {
+func rewriteValue386_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14435,7 +14387,7 @@
return true
}
}
-func rewriteValue386_OpGreater16U_0(v *Value) bool {
+func rewriteValue386_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14452,7 +14404,7 @@
return true
}
}
-func rewriteValue386_OpGreater32_0(v *Value) bool {
+func rewriteValue386_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14469,7 +14421,7 @@
return true
}
}
-func rewriteValue386_OpGreater32F_0(v *Value) bool {
+func rewriteValue386_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14486,7 +14438,7 @@
return true
}
}
-func rewriteValue386_OpGreater32U_0(v *Value) bool {
+func rewriteValue386_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14503,7 +14455,7 @@
return true
}
}
-func rewriteValue386_OpGreater64F_0(v *Value) bool {
+func rewriteValue386_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14520,7 +14472,7 @@
return true
}
}
-func rewriteValue386_OpGreater8_0(v *Value) bool {
+func rewriteValue386_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14537,7 +14489,7 @@
return true
}
}
-func rewriteValue386_OpGreater8U_0(v *Value) bool {
+func rewriteValue386_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14554,7 +14506,7 @@
return true
}
}
-func rewriteValue386_OpHmul32_0(v *Value) bool {
+func rewriteValue386_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32 x y)
@@ -14568,7 +14520,7 @@
return true
}
}
-func rewriteValue386_OpHmul32u_0(v *Value) bool {
+func rewriteValue386_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32u x y)
@@ -14582,7 +14534,7 @@
return true
}
}
-func rewriteValue386_OpInterCall_0(v *Value) bool {
+func rewriteValue386_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -14598,7 +14550,7 @@
return true
}
}
-func rewriteValue386_OpIsInBounds_0(v *Value) bool {
+func rewriteValue386_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14615,7 +14567,7 @@
return true
}
}
-func rewriteValue386_OpIsNonNil_0(v *Value) bool {
+func rewriteValue386_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil p)
@@ -14630,7 +14582,7 @@
return true
}
}
-func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValue386_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14647,7 +14599,7 @@
return true
}
}
-func rewriteValue386_OpLeq16_0(v *Value) bool {
+func rewriteValue386_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14664,7 +14616,7 @@
return true
}
}
-func rewriteValue386_OpLeq16U_0(v *Value) bool {
+func rewriteValue386_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14681,7 +14633,7 @@
return true
}
}
-func rewriteValue386_OpLeq32_0(v *Value) bool {
+func rewriteValue386_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14698,7 +14650,7 @@
return true
}
}
-func rewriteValue386_OpLeq32F_0(v *Value) bool {
+func rewriteValue386_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14715,7 +14667,7 @@
return true
}
}
-func rewriteValue386_OpLeq32U_0(v *Value) bool {
+func rewriteValue386_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14732,7 +14684,7 @@
return true
}
}
-func rewriteValue386_OpLeq64F_0(v *Value) bool {
+func rewriteValue386_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14749,7 +14701,7 @@
return true
}
}
-func rewriteValue386_OpLeq8_0(v *Value) bool {
+func rewriteValue386_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14766,7 +14718,7 @@
return true
}
}
-func rewriteValue386_OpLeq8U_0(v *Value) bool {
+func rewriteValue386_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14783,7 +14735,7 @@
return true
}
}
-func rewriteValue386_OpLess16_0(v *Value) bool {
+func rewriteValue386_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14800,7 +14752,7 @@
return true
}
}
-func rewriteValue386_OpLess16U_0(v *Value) bool {
+func rewriteValue386_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14817,7 +14769,7 @@
return true
}
}
-func rewriteValue386_OpLess32_0(v *Value) bool {
+func rewriteValue386_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14834,7 +14786,7 @@
return true
}
}
-func rewriteValue386_OpLess32F_0(v *Value) bool {
+func rewriteValue386_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14851,7 +14803,7 @@
return true
}
}
-func rewriteValue386_OpLess32U_0(v *Value) bool {
+func rewriteValue386_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14868,7 +14820,7 @@
return true
}
}
-func rewriteValue386_OpLess64F_0(v *Value) bool {
+func rewriteValue386_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14885,7 +14837,7 @@
return true
}
}
-func rewriteValue386_OpLess8_0(v *Value) bool {
+func rewriteValue386_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14902,7 +14854,7 @@
return true
}
}
-func rewriteValue386_OpLess8U_0(v *Value) bool {
+func rewriteValue386_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14919,7 +14871,7 @@
return true
}
}
-func rewriteValue386_OpLoad_0(v *Value) bool {
+func rewriteValue386_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -14999,7 +14951,7 @@
}
return false
}
-func rewriteValue386_OpLocalAddr_0(v *Value) bool {
+func rewriteValue386_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (LEAL {sym} base)
@@ -15012,7 +14964,7 @@
return true
}
}
-func rewriteValue386_OpLsh16x16_0(v *Value) bool {
+func rewriteValue386_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15036,7 +14988,7 @@
return true
}
}
-func rewriteValue386_OpLsh16x32_0(v *Value) bool {
+func rewriteValue386_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15060,7 +15012,7 @@
return true
}
}
-func rewriteValue386_OpLsh16x64_0(v *Value) bool {
+func rewriteValue386_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -15097,7 +15049,7 @@
}
return false
}
-func rewriteValue386_OpLsh16x8_0(v *Value) bool {
+func rewriteValue386_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15121,7 +15073,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x16_0(v *Value) bool {
+func rewriteValue386_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15145,7 +15097,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x32_0(v *Value) bool {
+func rewriteValue386_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15169,7 +15121,7 @@
return true
}
}
-func rewriteValue386_OpLsh32x64_0(v *Value) bool {
+func rewriteValue386_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -15206,7 +15158,7 @@
}
return false
}
-func rewriteValue386_OpLsh32x8_0(v *Value) bool {
+func rewriteValue386_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15230,7 +15182,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x16_0(v *Value) bool {
+func rewriteValue386_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15254,7 +15206,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x32_0(v *Value) bool {
+func rewriteValue386_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15278,7 +15230,7 @@
return true
}
}
-func rewriteValue386_OpLsh8x64_0(v *Value) bool {
+func rewriteValue386_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -15315,7 +15267,7 @@
}
return false
}
-func rewriteValue386_OpLsh8x8_0(v *Value) bool {
+func rewriteValue386_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15339,7 +15291,7 @@
return true
}
}
-func rewriteValue386_OpMod16_0(v *Value) bool {
+func rewriteValue386_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod16 [a] x y)
@@ -15355,7 +15307,7 @@
return true
}
}
-func rewriteValue386_OpMod16u_0(v *Value) bool {
+func rewriteValue386_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod16u x y)
@@ -15369,7 +15321,7 @@
return true
}
}
-func rewriteValue386_OpMod32_0(v *Value) bool {
+func rewriteValue386_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32 [a] x y)
@@ -15385,7 +15337,7 @@
return true
}
}
-func rewriteValue386_OpMod32u_0(v *Value) bool {
+func rewriteValue386_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32u x y)
@@ -15399,7 +15351,7 @@
return true
}
}
-func rewriteValue386_OpMod8_0(v *Value) bool {
+func rewriteValue386_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15419,7 +15371,7 @@
return true
}
}
-func rewriteValue386_OpMod8u_0(v *Value) bool {
+func rewriteValue386_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15439,11 +15391,12 @@
return true
}
}
-func rewriteValue386_OpMove_0(v *Value) bool {
+func rewriteValue386_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Move [0] _ _ mem)
// result: mem
@@ -15677,15 +15630,6 @@
v.AddArg(v2)
return true
}
- return false
-}
-func rewriteValue386_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.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)
@@ -15726,7 +15670,7 @@
}
return false
}
-func rewriteValue386_OpMul16_0(v *Value) bool {
+func rewriteValue386_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -15740,7 +15684,7 @@
return true
}
}
-func rewriteValue386_OpMul32_0(v *Value) bool {
+func rewriteValue386_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -15754,7 +15698,7 @@
return true
}
}
-func rewriteValue386_OpMul32F_0(v *Value) bool {
+func rewriteValue386_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -15768,7 +15712,7 @@
return true
}
}
-func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
+func rewriteValue386_OpMul32uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32uhilo x y)
@@ -15782,7 +15726,7 @@
return true
}
}
-func rewriteValue386_OpMul64F_0(v *Value) bool {
+func rewriteValue386_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -15796,7 +15740,7 @@
return true
}
}
-func rewriteValue386_OpMul8_0(v *Value) bool {
+func rewriteValue386_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -15810,7 +15754,7 @@
return true
}
}
-func rewriteValue386_OpNeg16_0(v *Value) bool {
+func rewriteValue386_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEGL x)
@@ -15821,7 +15765,7 @@
return true
}
}
-func rewriteValue386_OpNeg32_0(v *Value) bool {
+func rewriteValue386_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEGL x)
@@ -15832,7 +15776,7 @@
return true
}
}
-func rewriteValue386_OpNeg32F_0(v *Value) bool {
+func rewriteValue386_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -15866,7 +15810,7 @@
}
return false
}
-func rewriteValue386_OpNeg64F_0(v *Value) bool {
+func rewriteValue386_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -15900,7 +15844,7 @@
}
return false
}
-func rewriteValue386_OpNeg8_0(v *Value) bool {
+func rewriteValue386_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEGL x)
@@ -15911,7 +15855,7 @@
return true
}
}
-func rewriteValue386_OpNeq16_0(v *Value) bool {
+func rewriteValue386_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15928,7 +15872,7 @@
return true
}
}
-func rewriteValue386_OpNeq32_0(v *Value) bool {
+func rewriteValue386_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15945,7 +15889,7 @@
return true
}
}
-func rewriteValue386_OpNeq32F_0(v *Value) bool {
+func rewriteValue386_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15962,7 +15906,7 @@
return true
}
}
-func rewriteValue386_OpNeq64F_0(v *Value) bool {
+func rewriteValue386_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15979,7 +15923,7 @@
return true
}
}
-func rewriteValue386_OpNeq8_0(v *Value) bool {
+func rewriteValue386_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15996,7 +15940,7 @@
return true
}
}
-func rewriteValue386_OpNeqB_0(v *Value) bool {
+func rewriteValue386_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16013,7 +15957,7 @@
return true
}
}
-func rewriteValue386_OpNeqPtr_0(v *Value) bool {
+func rewriteValue386_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16030,7 +15974,7 @@
return true
}
}
-func rewriteValue386_OpNilCheck_0(v *Value) bool {
+func rewriteValue386_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -16044,7 +15988,7 @@
return true
}
}
-func rewriteValue386_OpNot_0(v *Value) bool {
+func rewriteValue386_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORLconst [1] x)
@@ -16056,7 +16000,7 @@
return true
}
}
-func rewriteValue386_OpOffPtr_0(v *Value) bool {
+func rewriteValue386_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr)
// result: (ADDLconst [off] ptr)
@@ -16069,7 +16013,7 @@
return true
}
}
-func rewriteValue386_OpOr16_0(v *Value) bool {
+func rewriteValue386_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -16083,7 +16027,7 @@
return true
}
}
-func rewriteValue386_OpOr32_0(v *Value) bool {
+func rewriteValue386_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -16097,7 +16041,7 @@
return true
}
}
-func rewriteValue386_OpOr8_0(v *Value) bool {
+func rewriteValue386_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -16111,7 +16055,7 @@
return true
}
}
-func rewriteValue386_OpOrB_0(v *Value) bool {
+func rewriteValue386_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -16125,7 +16069,7 @@
return true
}
}
-func rewriteValue386_OpPanicBounds_0(v *Value) bool {
+func rewriteValue386_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16185,7 +16129,7 @@
}
return false
}
-func rewriteValue386_OpPanicExtend_0(v *Value) bool {
+func rewriteValue386_OpPanicExtend(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -16252,7 +16196,7 @@
}
return false
}
-func rewriteValue386_OpRotateLeft16_0(v *Value) bool {
+func rewriteValue386_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft16 x (MOVLconst [c]))
@@ -16270,7 +16214,7 @@
}
return false
}
-func rewriteValue386_OpRotateLeft32_0(v *Value) bool {
+func rewriteValue386_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x (MOVLconst [c]))
@@ -16288,7 +16232,7 @@
}
return false
}
-func rewriteValue386_OpRotateLeft8_0(v *Value) bool {
+func rewriteValue386_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft8 x (MOVLconst [c]))
@@ -16306,7 +16250,7 @@
}
return false
}
-func rewriteValue386_OpRound32F_0(v *Value) bool {
+func rewriteValue386_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -16318,7 +16262,7 @@
return true
}
}
-func rewriteValue386_OpRound64F_0(v *Value) bool {
+func rewriteValue386_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -16330,7 +16274,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValue386_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16354,7 +16298,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValue386_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16378,7 +16322,7 @@
return true
}
}
-func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValue386_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh16Ux64 x (Const64 [c]))
@@ -16415,7 +16359,7 @@
}
return false
}
-func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValue386_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16439,7 +16383,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x16_0(v *Value) bool {
+func rewriteValue386_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16466,7 +16410,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x32_0(v *Value) bool {
+func rewriteValue386_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16493,7 +16437,7 @@
return true
}
}
-func rewriteValue386_OpRsh16x64_0(v *Value) bool {
+func rewriteValue386_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh16x64 x (Const64 [c]))
@@ -16532,7 +16476,7 @@
}
return false
}
-func rewriteValue386_OpRsh16x8_0(v *Value) bool {
+func rewriteValue386_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16559,7 +16503,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValue386_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16583,7 +16527,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValue386_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16607,7 +16551,7 @@
return true
}
}
-func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValue386_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -16644,7 +16588,7 @@
}
return false
}
-func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValue386_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16668,7 +16612,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x16_0(v *Value) bool {
+func rewriteValue386_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16695,7 +16639,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x32_0(v *Value) bool {
+func rewriteValue386_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16722,7 +16666,7 @@
return true
}
}
-func rewriteValue386_OpRsh32x64_0(v *Value) bool {
+func rewriteValue386_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -16761,7 +16705,7 @@
}
return false
}
-func rewriteValue386_OpRsh32x8_0(v *Value) bool {
+func rewriteValue386_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16788,7 +16732,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValue386_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16812,7 +16756,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValue386_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16836,7 +16780,7 @@
return true
}
}
-func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValue386_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh8Ux64 x (Const64 [c]))
@@ -16873,7 +16817,7 @@
}
return false
}
-func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValue386_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16897,7 +16841,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x16_0(v *Value) bool {
+func rewriteValue386_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16924,7 +16868,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x32_0(v *Value) bool {
+func rewriteValue386_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16951,7 +16895,7 @@
return true
}
}
-func rewriteValue386_OpRsh8x64_0(v *Value) bool {
+func rewriteValue386_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh8x64 x (Const64 [c]))
@@ -16990,7 +16934,7 @@
}
return false
}
-func rewriteValue386_OpRsh8x8_0(v *Value) bool {
+func rewriteValue386_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17017,7 +16961,7 @@
return true
}
}
-func rewriteValue386_OpSelect0_0(v *Value) bool {
+func rewriteValue386_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -17039,7 +16983,7 @@
}
return false
}
-func rewriteValue386_OpSelect1_0(v *Value) bool {
+func rewriteValue386_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -17062,7 +17006,7 @@
}
return false
}
-func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
+func rewriteValue386_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVWLSX x)
@@ -17073,7 +17017,7 @@
return true
}
}
-func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
+func rewriteValue386_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBLSX x)
@@ -17084,7 +17028,7 @@
return true
}
}
-func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
+func rewriteValue386_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBLSX x)
@@ -17095,7 +17039,7 @@
return true
}
}
-func rewriteValue386_OpSignmask_0(v *Value) bool {
+func rewriteValue386_OpSignmask(v *Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SARLconst x [31])
@@ -17107,7 +17051,7 @@
return true
}
}
-func rewriteValue386_OpSlicemask_0(v *Value) bool {
+func rewriteValue386_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -17123,7 +17067,7 @@
return true
}
}
-func rewriteValue386_OpSqrt_0(v *Value) bool {
+func rewriteValue386_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (SQRTSD x)
@@ -17134,7 +17078,7 @@
return true
}
}
-func rewriteValue386_OpStaticCall_0(v *Value) bool {
+func rewriteValue386_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -17149,7 +17093,7 @@
return true
}
}
-func rewriteValue386_OpStore_0(v *Value) bool {
+func rewriteValue386_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17240,7 +17184,7 @@
}
return false
}
-func rewriteValue386_OpSub16_0(v *Value) bool {
+func rewriteValue386_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -17254,7 +17198,7 @@
return true
}
}
-func rewriteValue386_OpSub32_0(v *Value) bool {
+func rewriteValue386_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -17268,7 +17212,7 @@
return true
}
}
-func rewriteValue386_OpSub32F_0(v *Value) bool {
+func rewriteValue386_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -17282,7 +17226,7 @@
return true
}
}
-func rewriteValue386_OpSub32carry_0(v *Value) bool {
+func rewriteValue386_OpSub32carry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32carry x y)
@@ -17296,7 +17240,7 @@
return true
}
}
-func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
+func rewriteValue386_OpSub32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17313,7 +17257,7 @@
return true
}
}
-func rewriteValue386_OpSub64F_0(v *Value) bool {
+func rewriteValue386_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -17327,7 +17271,7 @@
return true
}
}
-func rewriteValue386_OpSub8_0(v *Value) bool {
+func rewriteValue386_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -17341,7 +17285,7 @@
return true
}
}
-func rewriteValue386_OpSubPtr_0(v *Value) bool {
+func rewriteValue386_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -17355,7 +17299,7 @@
return true
}
}
-func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
+func rewriteValue386_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -17367,7 +17311,7 @@
return true
}
}
-func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
+func rewriteValue386_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -17379,7 +17323,7 @@
return true
}
}
-func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
+func rewriteValue386_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -17391,7 +17335,7 @@
return true
}
}
-func rewriteValue386_OpWB_0(v *Value) bool {
+func rewriteValue386_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17410,7 +17354,7 @@
return true
}
}
-func rewriteValue386_OpXor16_0(v *Value) bool {
+func rewriteValue386_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -17424,7 +17368,7 @@
return true
}
}
-func rewriteValue386_OpXor32_0(v *Value) bool {
+func rewriteValue386_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -17438,7 +17382,7 @@
return true
}
}
-func rewriteValue386_OpXor8_0(v *Value) bool {
+func rewriteValue386_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -17452,10 +17396,11 @@
return true
}
}
-func rewriteValue386_OpZero_0(v *Value) bool {
+func rewriteValue386_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Zero [0] _ mem)
// result: mem
@@ -17624,14 +17569,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValue386_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Zero [12] destptr mem)
// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)))
for {
@@ -17722,7 +17659,7 @@
}
return false
}
-func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValue386_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVWLZX x)
@@ -17733,7 +17670,7 @@
return true
}
}
-func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValue386_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBLZX x)
@@ -17744,7 +17681,7 @@
return true
}
}
-func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValue386_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBLZX x)
@@ -17755,7 +17692,7 @@
return true
}
}
-func rewriteValue386_OpZeromask_0(v *Value) bool {
+func rewriteValue386_OpZeromask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Zeromask <t> x)
diff --git a/src/cmd/compile/internal/ssa/rewrite386splitload.go b/src/cmd/compile/internal/ssa/rewrite386splitload.go
index 9f1c71a..cce1b2d 100644
--- a/src/cmd/compile/internal/ssa/rewrite386splitload.go
+++ b/src/cmd/compile/internal/ssa/rewrite386splitload.go
@@ -6,21 +6,21 @@
func rewriteValue386splitload(v *Value) bool {
switch v.Op {
case Op386CMPBconstload:
- return rewriteValue386splitload_Op386CMPBconstload_0(v)
+ return rewriteValue386splitload_Op386CMPBconstload(v)
case Op386CMPBload:
- return rewriteValue386splitload_Op386CMPBload_0(v)
+ return rewriteValue386splitload_Op386CMPBload(v)
case Op386CMPLconstload:
- return rewriteValue386splitload_Op386CMPLconstload_0(v)
+ return rewriteValue386splitload_Op386CMPLconstload(v)
case Op386CMPLload:
- return rewriteValue386splitload_Op386CMPLload_0(v)
+ return rewriteValue386splitload_Op386CMPLload(v)
case Op386CMPWconstload:
- return rewriteValue386splitload_Op386CMPWconstload_0(v)
+ return rewriteValue386splitload_Op386CMPWconstload(v)
case Op386CMPWload:
- return rewriteValue386splitload_Op386CMPWload_0(v)
+ return rewriteValue386splitload_Op386CMPWload(v)
}
return false
}
-func rewriteValue386splitload_Op386CMPBconstload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPBconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -43,7 +43,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPBload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPBload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -68,7 +68,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPLconstload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPLconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -91,7 +91,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPLload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -116,7 +116,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPWconstload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPWconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -139,7 +139,7 @@
return true
}
}
-func rewriteValue386splitload_Op386CMPWload_0(v *Value) bool {
+func rewriteValue386splitload_Op386CMPWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go
index 3c2e57b..df9f0d0 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go
@@ -9,589 +9,589 @@
func rewriteValueAMD64(v *Value) bool {
switch v.Op {
case OpAMD64ADCQ:
- return rewriteValueAMD64_OpAMD64ADCQ_0(v)
+ return rewriteValueAMD64_OpAMD64ADCQ(v)
case OpAMD64ADCQconst:
- return rewriteValueAMD64_OpAMD64ADCQconst_0(v)
+ return rewriteValueAMD64_OpAMD64ADCQconst(v)
case OpAMD64ADDL:
- return rewriteValueAMD64_OpAMD64ADDL_0(v) || rewriteValueAMD64_OpAMD64ADDL_10(v)
+ return rewriteValueAMD64_OpAMD64ADDL(v)
case OpAMD64ADDLconst:
- return rewriteValueAMD64_OpAMD64ADDLconst_0(v) || rewriteValueAMD64_OpAMD64ADDLconst_10(v)
+ return rewriteValueAMD64_OpAMD64ADDLconst(v)
case OpAMD64ADDLconstmodify:
- return rewriteValueAMD64_OpAMD64ADDLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ADDLconstmodify(v)
case OpAMD64ADDLload:
- return rewriteValueAMD64_OpAMD64ADDLload_0(v)
+ return rewriteValueAMD64_OpAMD64ADDLload(v)
case OpAMD64ADDLmodify:
- return rewriteValueAMD64_OpAMD64ADDLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ADDLmodify(v)
case OpAMD64ADDQ:
- return rewriteValueAMD64_OpAMD64ADDQ_0(v) || rewriteValueAMD64_OpAMD64ADDQ_10(v)
+ return rewriteValueAMD64_OpAMD64ADDQ(v)
case OpAMD64ADDQcarry:
- return rewriteValueAMD64_OpAMD64ADDQcarry_0(v)
+ return rewriteValueAMD64_OpAMD64ADDQcarry(v)
case OpAMD64ADDQconst:
- return rewriteValueAMD64_OpAMD64ADDQconst_0(v) || rewriteValueAMD64_OpAMD64ADDQconst_10(v)
+ return rewriteValueAMD64_OpAMD64ADDQconst(v)
case OpAMD64ADDQconstmodify:
- return rewriteValueAMD64_OpAMD64ADDQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ADDQconstmodify(v)
case OpAMD64ADDQload:
- return rewriteValueAMD64_OpAMD64ADDQload_0(v)
+ return rewriteValueAMD64_OpAMD64ADDQload(v)
case OpAMD64ADDQmodify:
- return rewriteValueAMD64_OpAMD64ADDQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ADDQmodify(v)
case OpAMD64ADDSD:
- return rewriteValueAMD64_OpAMD64ADDSD_0(v)
+ return rewriteValueAMD64_OpAMD64ADDSD(v)
case OpAMD64ADDSDload:
- return rewriteValueAMD64_OpAMD64ADDSDload_0(v)
+ return rewriteValueAMD64_OpAMD64ADDSDload(v)
case OpAMD64ADDSS:
- return rewriteValueAMD64_OpAMD64ADDSS_0(v)
+ return rewriteValueAMD64_OpAMD64ADDSS(v)
case OpAMD64ADDSSload:
- return rewriteValueAMD64_OpAMD64ADDSSload_0(v)
+ return rewriteValueAMD64_OpAMD64ADDSSload(v)
case OpAMD64ANDL:
- return rewriteValueAMD64_OpAMD64ANDL_0(v)
+ return rewriteValueAMD64_OpAMD64ANDL(v)
case OpAMD64ANDLconst:
- return rewriteValueAMD64_OpAMD64ANDLconst_0(v)
+ return rewriteValueAMD64_OpAMD64ANDLconst(v)
case OpAMD64ANDLconstmodify:
- return rewriteValueAMD64_OpAMD64ANDLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ANDLconstmodify(v)
case OpAMD64ANDLload:
- return rewriteValueAMD64_OpAMD64ANDLload_0(v)
+ return rewriteValueAMD64_OpAMD64ANDLload(v)
case OpAMD64ANDLmodify:
- return rewriteValueAMD64_OpAMD64ANDLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ANDLmodify(v)
case OpAMD64ANDQ:
- return rewriteValueAMD64_OpAMD64ANDQ_0(v)
+ return rewriteValueAMD64_OpAMD64ANDQ(v)
case OpAMD64ANDQconst:
- return rewriteValueAMD64_OpAMD64ANDQconst_0(v)
+ return rewriteValueAMD64_OpAMD64ANDQconst(v)
case OpAMD64ANDQconstmodify:
- return rewriteValueAMD64_OpAMD64ANDQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ANDQconstmodify(v)
case OpAMD64ANDQload:
- return rewriteValueAMD64_OpAMD64ANDQload_0(v)
+ return rewriteValueAMD64_OpAMD64ANDQload(v)
case OpAMD64ANDQmodify:
- return rewriteValueAMD64_OpAMD64ANDQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ANDQmodify(v)
case OpAMD64BSFQ:
- return rewriteValueAMD64_OpAMD64BSFQ_0(v)
+ return rewriteValueAMD64_OpAMD64BSFQ(v)
case OpAMD64BTCLconst:
- return rewriteValueAMD64_OpAMD64BTCLconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTCLconst(v)
case OpAMD64BTCLconstmodify:
- return rewriteValueAMD64_OpAMD64BTCLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTCLconstmodify(v)
case OpAMD64BTCLmodify:
- return rewriteValueAMD64_OpAMD64BTCLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTCLmodify(v)
case OpAMD64BTCQconst:
- return rewriteValueAMD64_OpAMD64BTCQconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTCQconst(v)
case OpAMD64BTCQconstmodify:
- return rewriteValueAMD64_OpAMD64BTCQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTCQconstmodify(v)
case OpAMD64BTCQmodify:
- return rewriteValueAMD64_OpAMD64BTCQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTCQmodify(v)
case OpAMD64BTLconst:
- return rewriteValueAMD64_OpAMD64BTLconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTLconst(v)
case OpAMD64BTQconst:
- return rewriteValueAMD64_OpAMD64BTQconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTQconst(v)
case OpAMD64BTRLconst:
- return rewriteValueAMD64_OpAMD64BTRLconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTRLconst(v)
case OpAMD64BTRLconstmodify:
- return rewriteValueAMD64_OpAMD64BTRLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTRLconstmodify(v)
case OpAMD64BTRLmodify:
- return rewriteValueAMD64_OpAMD64BTRLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTRLmodify(v)
case OpAMD64BTRQconst:
- return rewriteValueAMD64_OpAMD64BTRQconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTRQconst(v)
case OpAMD64BTRQconstmodify:
- return rewriteValueAMD64_OpAMD64BTRQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTRQconstmodify(v)
case OpAMD64BTRQmodify:
- return rewriteValueAMD64_OpAMD64BTRQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTRQmodify(v)
case OpAMD64BTSLconst:
- return rewriteValueAMD64_OpAMD64BTSLconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTSLconst(v)
case OpAMD64BTSLconstmodify:
- return rewriteValueAMD64_OpAMD64BTSLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTSLconstmodify(v)
case OpAMD64BTSLmodify:
- return rewriteValueAMD64_OpAMD64BTSLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTSLmodify(v)
case OpAMD64BTSQconst:
- return rewriteValueAMD64_OpAMD64BTSQconst_0(v)
+ return rewriteValueAMD64_OpAMD64BTSQconst(v)
case OpAMD64BTSQconstmodify:
- return rewriteValueAMD64_OpAMD64BTSQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTSQconstmodify(v)
case OpAMD64BTSQmodify:
- return rewriteValueAMD64_OpAMD64BTSQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64BTSQmodify(v)
case OpAMD64CMOVLCC:
- return rewriteValueAMD64_OpAMD64CMOVLCC_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLCC(v)
case OpAMD64CMOVLCS:
- return rewriteValueAMD64_OpAMD64CMOVLCS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLCS(v)
case OpAMD64CMOVLEQ:
- return rewriteValueAMD64_OpAMD64CMOVLEQ_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLEQ(v)
case OpAMD64CMOVLGE:
- return rewriteValueAMD64_OpAMD64CMOVLGE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLGE(v)
case OpAMD64CMOVLGT:
- return rewriteValueAMD64_OpAMD64CMOVLGT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLGT(v)
case OpAMD64CMOVLHI:
- return rewriteValueAMD64_OpAMD64CMOVLHI_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLHI(v)
case OpAMD64CMOVLLE:
- return rewriteValueAMD64_OpAMD64CMOVLLE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLLE(v)
case OpAMD64CMOVLLS:
- return rewriteValueAMD64_OpAMD64CMOVLLS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLLS(v)
case OpAMD64CMOVLLT:
- return rewriteValueAMD64_OpAMD64CMOVLLT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLLT(v)
case OpAMD64CMOVLNE:
- return rewriteValueAMD64_OpAMD64CMOVLNE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVLNE(v)
case OpAMD64CMOVQCC:
- return rewriteValueAMD64_OpAMD64CMOVQCC_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQCC(v)
case OpAMD64CMOVQCS:
- return rewriteValueAMD64_OpAMD64CMOVQCS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQCS(v)
case OpAMD64CMOVQEQ:
- return rewriteValueAMD64_OpAMD64CMOVQEQ_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQEQ(v)
case OpAMD64CMOVQGE:
- return rewriteValueAMD64_OpAMD64CMOVQGE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQGE(v)
case OpAMD64CMOVQGT:
- return rewriteValueAMD64_OpAMD64CMOVQGT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQGT(v)
case OpAMD64CMOVQHI:
- return rewriteValueAMD64_OpAMD64CMOVQHI_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQHI(v)
case OpAMD64CMOVQLE:
- return rewriteValueAMD64_OpAMD64CMOVQLE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQLE(v)
case OpAMD64CMOVQLS:
- return rewriteValueAMD64_OpAMD64CMOVQLS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQLS(v)
case OpAMD64CMOVQLT:
- return rewriteValueAMD64_OpAMD64CMOVQLT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQLT(v)
case OpAMD64CMOVQNE:
- return rewriteValueAMD64_OpAMD64CMOVQNE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVQNE(v)
case OpAMD64CMOVWCC:
- return rewriteValueAMD64_OpAMD64CMOVWCC_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWCC(v)
case OpAMD64CMOVWCS:
- return rewriteValueAMD64_OpAMD64CMOVWCS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWCS(v)
case OpAMD64CMOVWEQ:
- return rewriteValueAMD64_OpAMD64CMOVWEQ_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWEQ(v)
case OpAMD64CMOVWGE:
- return rewriteValueAMD64_OpAMD64CMOVWGE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWGE(v)
case OpAMD64CMOVWGT:
- return rewriteValueAMD64_OpAMD64CMOVWGT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWGT(v)
case OpAMD64CMOVWHI:
- return rewriteValueAMD64_OpAMD64CMOVWHI_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWHI(v)
case OpAMD64CMOVWLE:
- return rewriteValueAMD64_OpAMD64CMOVWLE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWLE(v)
case OpAMD64CMOVWLS:
- return rewriteValueAMD64_OpAMD64CMOVWLS_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWLS(v)
case OpAMD64CMOVWLT:
- return rewriteValueAMD64_OpAMD64CMOVWLT_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWLT(v)
case OpAMD64CMOVWNE:
- return rewriteValueAMD64_OpAMD64CMOVWNE_0(v)
+ return rewriteValueAMD64_OpAMD64CMOVWNE(v)
case OpAMD64CMPB:
- return rewriteValueAMD64_OpAMD64CMPB_0(v)
+ return rewriteValueAMD64_OpAMD64CMPB(v)
case OpAMD64CMPBconst:
- return rewriteValueAMD64_OpAMD64CMPBconst_0(v)
+ return rewriteValueAMD64_OpAMD64CMPBconst(v)
case OpAMD64CMPBconstload:
- return rewriteValueAMD64_OpAMD64CMPBconstload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPBconstload(v)
case OpAMD64CMPBload:
- return rewriteValueAMD64_OpAMD64CMPBload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPBload(v)
case OpAMD64CMPL:
- return rewriteValueAMD64_OpAMD64CMPL_0(v)
+ return rewriteValueAMD64_OpAMD64CMPL(v)
case OpAMD64CMPLconst:
- return rewriteValueAMD64_OpAMD64CMPLconst_0(v) || rewriteValueAMD64_OpAMD64CMPLconst_10(v)
+ return rewriteValueAMD64_OpAMD64CMPLconst(v)
case OpAMD64CMPLconstload:
- return rewriteValueAMD64_OpAMD64CMPLconstload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPLconstload(v)
case OpAMD64CMPLload:
- return rewriteValueAMD64_OpAMD64CMPLload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPLload(v)
case OpAMD64CMPQ:
- return rewriteValueAMD64_OpAMD64CMPQ_0(v)
+ return rewriteValueAMD64_OpAMD64CMPQ(v)
case OpAMD64CMPQconst:
- return rewriteValueAMD64_OpAMD64CMPQconst_0(v) || rewriteValueAMD64_OpAMD64CMPQconst_10(v)
+ return rewriteValueAMD64_OpAMD64CMPQconst(v)
case OpAMD64CMPQconstload:
- return rewriteValueAMD64_OpAMD64CMPQconstload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPQconstload(v)
case OpAMD64CMPQload:
- return rewriteValueAMD64_OpAMD64CMPQload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPQload(v)
case OpAMD64CMPW:
- return rewriteValueAMD64_OpAMD64CMPW_0(v)
+ return rewriteValueAMD64_OpAMD64CMPW(v)
case OpAMD64CMPWconst:
- return rewriteValueAMD64_OpAMD64CMPWconst_0(v)
+ return rewriteValueAMD64_OpAMD64CMPWconst(v)
case OpAMD64CMPWconstload:
- return rewriteValueAMD64_OpAMD64CMPWconstload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPWconstload(v)
case OpAMD64CMPWload:
- return rewriteValueAMD64_OpAMD64CMPWload_0(v)
+ return rewriteValueAMD64_OpAMD64CMPWload(v)
case OpAMD64CMPXCHGLlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v)
case OpAMD64CMPXCHGQlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v)
case OpAMD64DIVSD:
- return rewriteValueAMD64_OpAMD64DIVSD_0(v)
+ return rewriteValueAMD64_OpAMD64DIVSD(v)
case OpAMD64DIVSDload:
- return rewriteValueAMD64_OpAMD64DIVSDload_0(v)
+ return rewriteValueAMD64_OpAMD64DIVSDload(v)
case OpAMD64DIVSS:
- return rewriteValueAMD64_OpAMD64DIVSS_0(v)
+ return rewriteValueAMD64_OpAMD64DIVSS(v)
case OpAMD64DIVSSload:
- return rewriteValueAMD64_OpAMD64DIVSSload_0(v)
+ return rewriteValueAMD64_OpAMD64DIVSSload(v)
case OpAMD64HMULL:
- return rewriteValueAMD64_OpAMD64HMULL_0(v)
+ return rewriteValueAMD64_OpAMD64HMULL(v)
case OpAMD64HMULLU:
- return rewriteValueAMD64_OpAMD64HMULLU_0(v)
+ return rewriteValueAMD64_OpAMD64HMULLU(v)
case OpAMD64HMULQ:
- return rewriteValueAMD64_OpAMD64HMULQ_0(v)
+ return rewriteValueAMD64_OpAMD64HMULQ(v)
case OpAMD64HMULQU:
- return rewriteValueAMD64_OpAMD64HMULQU_0(v)
+ return rewriteValueAMD64_OpAMD64HMULQU(v)
case OpAMD64LEAL:
- return rewriteValueAMD64_OpAMD64LEAL_0(v)
+ return rewriteValueAMD64_OpAMD64LEAL(v)
case OpAMD64LEAL1:
- return rewriteValueAMD64_OpAMD64LEAL1_0(v)
+ return rewriteValueAMD64_OpAMD64LEAL1(v)
case OpAMD64LEAL2:
- return rewriteValueAMD64_OpAMD64LEAL2_0(v)
+ return rewriteValueAMD64_OpAMD64LEAL2(v)
case OpAMD64LEAL4:
- return rewriteValueAMD64_OpAMD64LEAL4_0(v)
+ return rewriteValueAMD64_OpAMD64LEAL4(v)
case OpAMD64LEAL8:
- return rewriteValueAMD64_OpAMD64LEAL8_0(v)
+ return rewriteValueAMD64_OpAMD64LEAL8(v)
case OpAMD64LEAQ:
- return rewriteValueAMD64_OpAMD64LEAQ_0(v)
+ return rewriteValueAMD64_OpAMD64LEAQ(v)
case OpAMD64LEAQ1:
- return rewriteValueAMD64_OpAMD64LEAQ1_0(v)
+ return rewriteValueAMD64_OpAMD64LEAQ1(v)
case OpAMD64LEAQ2:
- return rewriteValueAMD64_OpAMD64LEAQ2_0(v)
+ return rewriteValueAMD64_OpAMD64LEAQ2(v)
case OpAMD64LEAQ4:
- return rewriteValueAMD64_OpAMD64LEAQ4_0(v)
+ return rewriteValueAMD64_OpAMD64LEAQ4(v)
case OpAMD64LEAQ8:
- return rewriteValueAMD64_OpAMD64LEAQ8_0(v)
+ return rewriteValueAMD64_OpAMD64LEAQ8(v)
case OpAMD64MOVBQSX:
- return rewriteValueAMD64_OpAMD64MOVBQSX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSX(v)
case OpAMD64MOVBQSXload:
- return rewriteValueAMD64_OpAMD64MOVBQSXload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSXload(v)
case OpAMD64MOVBQZX:
- return rewriteValueAMD64_OpAMD64MOVBQZX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBQZX(v)
case OpAMD64MOVBatomicload:
- return rewriteValueAMD64_OpAMD64MOVBatomicload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBatomicload(v)
case OpAMD64MOVBload:
- return rewriteValueAMD64_OpAMD64MOVBload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBload(v)
case OpAMD64MOVBloadidx1:
- return rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBloadidx1(v)
case OpAMD64MOVBstore:
- return rewriteValueAMD64_OpAMD64MOVBstore_0(v) || rewriteValueAMD64_OpAMD64MOVBstore_10(v) || rewriteValueAMD64_OpAMD64MOVBstore_20(v) || rewriteValueAMD64_OpAMD64MOVBstore_30(v)
+ return rewriteValueAMD64_OpAMD64MOVBstore(v)
case OpAMD64MOVBstoreconst:
- return rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconst(v)
case OpAMD64MOVBstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v)
case OpAMD64MOVBstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v) || rewriteValueAMD64_OpAMD64MOVBstoreidx1_10(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v)
case OpAMD64MOVLQSX:
- return rewriteValueAMD64_OpAMD64MOVLQSX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSX(v)
case OpAMD64MOVLQSXload:
- return rewriteValueAMD64_OpAMD64MOVLQSXload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSXload(v)
case OpAMD64MOVLQZX:
- return rewriteValueAMD64_OpAMD64MOVLQZX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLQZX(v)
case OpAMD64MOVLatomicload:
- return rewriteValueAMD64_OpAMD64MOVLatomicload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLatomicload(v)
case OpAMD64MOVLf2i:
- return rewriteValueAMD64_OpAMD64MOVLf2i_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLf2i(v)
case OpAMD64MOVLi2f:
- return rewriteValueAMD64_OpAMD64MOVLi2f_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLi2f(v)
case OpAMD64MOVLload:
- return rewriteValueAMD64_OpAMD64MOVLload_0(v) || rewriteValueAMD64_OpAMD64MOVLload_10(v)
+ return rewriteValueAMD64_OpAMD64MOVLload(v)
case OpAMD64MOVLloadidx1:
- return rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx1(v)
case OpAMD64MOVLloadidx4:
- return rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx4(v)
case OpAMD64MOVLloadidx8:
- return rewriteValueAMD64_OpAMD64MOVLloadidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx8(v)
case OpAMD64MOVLstore:
- return rewriteValueAMD64_OpAMD64MOVLstore_0(v) || rewriteValueAMD64_OpAMD64MOVLstore_10(v) || rewriteValueAMD64_OpAMD64MOVLstore_20(v) || rewriteValueAMD64_OpAMD64MOVLstore_30(v)
+ return rewriteValueAMD64_OpAMD64MOVLstore(v)
case OpAMD64MOVLstoreconst:
- return rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconst(v)
case OpAMD64MOVLstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v)
case OpAMD64MOVLstoreconstidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v)
case OpAMD64MOVLstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v)
case OpAMD64MOVLstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v)
case OpAMD64MOVLstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx8(v)
case OpAMD64MOVOload:
- return rewriteValueAMD64_OpAMD64MOVOload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVOload(v)
case OpAMD64MOVOstore:
- return rewriteValueAMD64_OpAMD64MOVOstore_0(v)
+ return rewriteValueAMD64_OpAMD64MOVOstore(v)
case OpAMD64MOVQatomicload:
- return rewriteValueAMD64_OpAMD64MOVQatomicload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQatomicload(v)
case OpAMD64MOVQf2i:
- return rewriteValueAMD64_OpAMD64MOVQf2i_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQf2i(v)
case OpAMD64MOVQi2f:
- return rewriteValueAMD64_OpAMD64MOVQi2f_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQi2f(v)
case OpAMD64MOVQload:
- return rewriteValueAMD64_OpAMD64MOVQload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQload(v)
case OpAMD64MOVQloadidx1:
- return rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx1(v)
case OpAMD64MOVQloadidx8:
- return rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx8(v)
case OpAMD64MOVQstore:
- return rewriteValueAMD64_OpAMD64MOVQstore_0(v) || rewriteValueAMD64_OpAMD64MOVQstore_10(v) || rewriteValueAMD64_OpAMD64MOVQstore_20(v)
+ return rewriteValueAMD64_OpAMD64MOVQstore(v)
case OpAMD64MOVQstoreconst:
- return rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconst(v)
case OpAMD64MOVQstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v)
case OpAMD64MOVQstoreconstidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v)
case OpAMD64MOVQstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v)
case OpAMD64MOVQstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v)
case OpAMD64MOVSDload:
- return rewriteValueAMD64_OpAMD64MOVSDload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDload(v)
case OpAMD64MOVSDloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v)
case OpAMD64MOVSDloadidx8:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v)
case OpAMD64MOVSDstore:
- return rewriteValueAMD64_OpAMD64MOVSDstore_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstore(v)
case OpAMD64MOVSDstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v)
case OpAMD64MOVSDstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v)
case OpAMD64MOVSSload:
- return rewriteValueAMD64_OpAMD64MOVSSload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSload(v)
case OpAMD64MOVSSloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v)
case OpAMD64MOVSSloadidx4:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v)
case OpAMD64MOVSSstore:
- return rewriteValueAMD64_OpAMD64MOVSSstore_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstore(v)
case OpAMD64MOVSSstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v)
case OpAMD64MOVSSstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v)
case OpAMD64MOVWQSX:
- return rewriteValueAMD64_OpAMD64MOVWQSX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSX(v)
case OpAMD64MOVWQSXload:
- return rewriteValueAMD64_OpAMD64MOVWQSXload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSXload(v)
case OpAMD64MOVWQZX:
- return rewriteValueAMD64_OpAMD64MOVWQZX_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWQZX(v)
case OpAMD64MOVWload:
- return rewriteValueAMD64_OpAMD64MOVWload_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWload(v)
case OpAMD64MOVWloadidx1:
- return rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx1(v)
case OpAMD64MOVWloadidx2:
- return rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx2(v)
case OpAMD64MOVWstore:
- return rewriteValueAMD64_OpAMD64MOVWstore_0(v) || rewriteValueAMD64_OpAMD64MOVWstore_10(v)
+ return rewriteValueAMD64_OpAMD64MOVWstore(v)
case OpAMD64MOVWstoreconst:
- return rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconst(v)
case OpAMD64MOVWstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v)
case OpAMD64MOVWstoreconstidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v)
case OpAMD64MOVWstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v)
case OpAMD64MOVWstoreidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v)
case OpAMD64MULL:
- return rewriteValueAMD64_OpAMD64MULL_0(v)
+ return rewriteValueAMD64_OpAMD64MULL(v)
case OpAMD64MULLconst:
- return rewriteValueAMD64_OpAMD64MULLconst_0(v) || rewriteValueAMD64_OpAMD64MULLconst_10(v) || rewriteValueAMD64_OpAMD64MULLconst_20(v) || rewriteValueAMD64_OpAMD64MULLconst_30(v)
+ return rewriteValueAMD64_OpAMD64MULLconst(v)
case OpAMD64MULQ:
- return rewriteValueAMD64_OpAMD64MULQ_0(v)
+ return rewriteValueAMD64_OpAMD64MULQ(v)
case OpAMD64MULQconst:
- return rewriteValueAMD64_OpAMD64MULQconst_0(v) || rewriteValueAMD64_OpAMD64MULQconst_10(v) || rewriteValueAMD64_OpAMD64MULQconst_20(v) || rewriteValueAMD64_OpAMD64MULQconst_30(v)
+ return rewriteValueAMD64_OpAMD64MULQconst(v)
case OpAMD64MULSD:
- return rewriteValueAMD64_OpAMD64MULSD_0(v)
+ return rewriteValueAMD64_OpAMD64MULSD(v)
case OpAMD64MULSDload:
- return rewriteValueAMD64_OpAMD64MULSDload_0(v)
+ return rewriteValueAMD64_OpAMD64MULSDload(v)
case OpAMD64MULSS:
- return rewriteValueAMD64_OpAMD64MULSS_0(v)
+ return rewriteValueAMD64_OpAMD64MULSS(v)
case OpAMD64MULSSload:
- return rewriteValueAMD64_OpAMD64MULSSload_0(v)
+ return rewriteValueAMD64_OpAMD64MULSSload(v)
case OpAMD64NEGL:
- return rewriteValueAMD64_OpAMD64NEGL_0(v)
+ return rewriteValueAMD64_OpAMD64NEGL(v)
case OpAMD64NEGQ:
- return rewriteValueAMD64_OpAMD64NEGQ_0(v)
+ return rewriteValueAMD64_OpAMD64NEGQ(v)
case OpAMD64NOTL:
- return rewriteValueAMD64_OpAMD64NOTL_0(v)
+ return rewriteValueAMD64_OpAMD64NOTL(v)
case OpAMD64NOTQ:
- return rewriteValueAMD64_OpAMD64NOTQ_0(v)
+ return rewriteValueAMD64_OpAMD64NOTQ(v)
case OpAMD64ORL:
- return rewriteValueAMD64_OpAMD64ORL_0(v) || rewriteValueAMD64_OpAMD64ORL_10(v) || rewriteValueAMD64_OpAMD64ORL_20(v) || rewriteValueAMD64_OpAMD64ORL_30(v)
+ return rewriteValueAMD64_OpAMD64ORL(v)
case OpAMD64ORLconst:
- return rewriteValueAMD64_OpAMD64ORLconst_0(v)
+ return rewriteValueAMD64_OpAMD64ORLconst(v)
case OpAMD64ORLconstmodify:
- return rewriteValueAMD64_OpAMD64ORLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ORLconstmodify(v)
case OpAMD64ORLload:
- return rewriteValueAMD64_OpAMD64ORLload_0(v)
+ return rewriteValueAMD64_OpAMD64ORLload(v)
case OpAMD64ORLmodify:
- return rewriteValueAMD64_OpAMD64ORLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ORLmodify(v)
case OpAMD64ORQ:
- return rewriteValueAMD64_OpAMD64ORQ_0(v) || rewriteValueAMD64_OpAMD64ORQ_10(v) || rewriteValueAMD64_OpAMD64ORQ_20(v)
+ return rewriteValueAMD64_OpAMD64ORQ(v)
case OpAMD64ORQconst:
- return rewriteValueAMD64_OpAMD64ORQconst_0(v)
+ return rewriteValueAMD64_OpAMD64ORQconst(v)
case OpAMD64ORQconstmodify:
- return rewriteValueAMD64_OpAMD64ORQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ORQconstmodify(v)
case OpAMD64ORQload:
- return rewriteValueAMD64_OpAMD64ORQload_0(v)
+ return rewriteValueAMD64_OpAMD64ORQload(v)
case OpAMD64ORQmodify:
- return rewriteValueAMD64_OpAMD64ORQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64ORQmodify(v)
case OpAMD64ROLB:
- return rewriteValueAMD64_OpAMD64ROLB_0(v)
+ return rewriteValueAMD64_OpAMD64ROLB(v)
case OpAMD64ROLBconst:
- return rewriteValueAMD64_OpAMD64ROLBconst_0(v)
+ return rewriteValueAMD64_OpAMD64ROLBconst(v)
case OpAMD64ROLL:
- return rewriteValueAMD64_OpAMD64ROLL_0(v)
+ return rewriteValueAMD64_OpAMD64ROLL(v)
case OpAMD64ROLLconst:
- return rewriteValueAMD64_OpAMD64ROLLconst_0(v)
+ return rewriteValueAMD64_OpAMD64ROLLconst(v)
case OpAMD64ROLQ:
- return rewriteValueAMD64_OpAMD64ROLQ_0(v)
+ return rewriteValueAMD64_OpAMD64ROLQ(v)
case OpAMD64ROLQconst:
- return rewriteValueAMD64_OpAMD64ROLQconst_0(v)
+ return rewriteValueAMD64_OpAMD64ROLQconst(v)
case OpAMD64ROLW:
- return rewriteValueAMD64_OpAMD64ROLW_0(v)
+ return rewriteValueAMD64_OpAMD64ROLW(v)
case OpAMD64ROLWconst:
- return rewriteValueAMD64_OpAMD64ROLWconst_0(v)
+ return rewriteValueAMD64_OpAMD64ROLWconst(v)
case OpAMD64RORB:
- return rewriteValueAMD64_OpAMD64RORB_0(v)
+ return rewriteValueAMD64_OpAMD64RORB(v)
case OpAMD64RORL:
- return rewriteValueAMD64_OpAMD64RORL_0(v)
+ return rewriteValueAMD64_OpAMD64RORL(v)
case OpAMD64RORQ:
- return rewriteValueAMD64_OpAMD64RORQ_0(v)
+ return rewriteValueAMD64_OpAMD64RORQ(v)
case OpAMD64RORW:
- return rewriteValueAMD64_OpAMD64RORW_0(v)
+ return rewriteValueAMD64_OpAMD64RORW(v)
case OpAMD64SARB:
- return rewriteValueAMD64_OpAMD64SARB_0(v)
+ return rewriteValueAMD64_OpAMD64SARB(v)
case OpAMD64SARBconst:
- return rewriteValueAMD64_OpAMD64SARBconst_0(v)
+ return rewriteValueAMD64_OpAMD64SARBconst(v)
case OpAMD64SARL:
- return rewriteValueAMD64_OpAMD64SARL_0(v)
+ return rewriteValueAMD64_OpAMD64SARL(v)
case OpAMD64SARLconst:
- return rewriteValueAMD64_OpAMD64SARLconst_0(v)
+ return rewriteValueAMD64_OpAMD64SARLconst(v)
case OpAMD64SARQ:
- return rewriteValueAMD64_OpAMD64SARQ_0(v)
+ return rewriteValueAMD64_OpAMD64SARQ(v)
case OpAMD64SARQconst:
- return rewriteValueAMD64_OpAMD64SARQconst_0(v)
+ return rewriteValueAMD64_OpAMD64SARQconst(v)
case OpAMD64SARW:
- return rewriteValueAMD64_OpAMD64SARW_0(v)
+ return rewriteValueAMD64_OpAMD64SARW(v)
case OpAMD64SARWconst:
- return rewriteValueAMD64_OpAMD64SARWconst_0(v)
+ return rewriteValueAMD64_OpAMD64SARWconst(v)
case OpAMD64SBBLcarrymask:
- return rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v)
+ return rewriteValueAMD64_OpAMD64SBBLcarrymask(v)
case OpAMD64SBBQ:
- return rewriteValueAMD64_OpAMD64SBBQ_0(v)
+ return rewriteValueAMD64_OpAMD64SBBQ(v)
case OpAMD64SBBQcarrymask:
- return rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v)
+ return rewriteValueAMD64_OpAMD64SBBQcarrymask(v)
case OpAMD64SBBQconst:
- return rewriteValueAMD64_OpAMD64SBBQconst_0(v)
+ return rewriteValueAMD64_OpAMD64SBBQconst(v)
case OpAMD64SETA:
- return rewriteValueAMD64_OpAMD64SETA_0(v)
+ return rewriteValueAMD64_OpAMD64SETA(v)
case OpAMD64SETAE:
- return rewriteValueAMD64_OpAMD64SETAE_0(v)
+ return rewriteValueAMD64_OpAMD64SETAE(v)
case OpAMD64SETAEstore:
- return rewriteValueAMD64_OpAMD64SETAEstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETAEstore(v)
case OpAMD64SETAstore:
- return rewriteValueAMD64_OpAMD64SETAstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETAstore(v)
case OpAMD64SETB:
- return rewriteValueAMD64_OpAMD64SETB_0(v)
+ return rewriteValueAMD64_OpAMD64SETB(v)
case OpAMD64SETBE:
- return rewriteValueAMD64_OpAMD64SETBE_0(v)
+ return rewriteValueAMD64_OpAMD64SETBE(v)
case OpAMD64SETBEstore:
- return rewriteValueAMD64_OpAMD64SETBEstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETBEstore(v)
case OpAMD64SETBstore:
- return rewriteValueAMD64_OpAMD64SETBstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETBstore(v)
case OpAMD64SETEQ:
- return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v)
+ return rewriteValueAMD64_OpAMD64SETEQ(v)
case OpAMD64SETEQstore:
- return rewriteValueAMD64_OpAMD64SETEQstore_0(v) || rewriteValueAMD64_OpAMD64SETEQstore_10(v) || rewriteValueAMD64_OpAMD64SETEQstore_20(v)
+ return rewriteValueAMD64_OpAMD64SETEQstore(v)
case OpAMD64SETG:
- return rewriteValueAMD64_OpAMD64SETG_0(v)
+ return rewriteValueAMD64_OpAMD64SETG(v)
case OpAMD64SETGE:
- return rewriteValueAMD64_OpAMD64SETGE_0(v)
+ return rewriteValueAMD64_OpAMD64SETGE(v)
case OpAMD64SETGEstore:
- return rewriteValueAMD64_OpAMD64SETGEstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETGEstore(v)
case OpAMD64SETGstore:
- return rewriteValueAMD64_OpAMD64SETGstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETGstore(v)
case OpAMD64SETL:
- return rewriteValueAMD64_OpAMD64SETL_0(v)
+ return rewriteValueAMD64_OpAMD64SETL(v)
case OpAMD64SETLE:
- return rewriteValueAMD64_OpAMD64SETLE_0(v)
+ return rewriteValueAMD64_OpAMD64SETLE(v)
case OpAMD64SETLEstore:
- return rewriteValueAMD64_OpAMD64SETLEstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETLEstore(v)
case OpAMD64SETLstore:
- return rewriteValueAMD64_OpAMD64SETLstore_0(v)
+ return rewriteValueAMD64_OpAMD64SETLstore(v)
case OpAMD64SETNE:
- return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v)
+ return rewriteValueAMD64_OpAMD64SETNE(v)
case OpAMD64SETNEstore:
- return rewriteValueAMD64_OpAMD64SETNEstore_0(v) || rewriteValueAMD64_OpAMD64SETNEstore_10(v) || rewriteValueAMD64_OpAMD64SETNEstore_20(v)
+ return rewriteValueAMD64_OpAMD64SETNEstore(v)
case OpAMD64SHLL:
- return rewriteValueAMD64_OpAMD64SHLL_0(v)
+ return rewriteValueAMD64_OpAMD64SHLL(v)
case OpAMD64SHLLconst:
- return rewriteValueAMD64_OpAMD64SHLLconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHLLconst(v)
case OpAMD64SHLQ:
- return rewriteValueAMD64_OpAMD64SHLQ_0(v)
+ return rewriteValueAMD64_OpAMD64SHLQ(v)
case OpAMD64SHLQconst:
- return rewriteValueAMD64_OpAMD64SHLQconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHLQconst(v)
case OpAMD64SHRB:
- return rewriteValueAMD64_OpAMD64SHRB_0(v)
+ return rewriteValueAMD64_OpAMD64SHRB(v)
case OpAMD64SHRBconst:
- return rewriteValueAMD64_OpAMD64SHRBconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHRBconst(v)
case OpAMD64SHRL:
- return rewriteValueAMD64_OpAMD64SHRL_0(v)
+ return rewriteValueAMD64_OpAMD64SHRL(v)
case OpAMD64SHRLconst:
- return rewriteValueAMD64_OpAMD64SHRLconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHRLconst(v)
case OpAMD64SHRQ:
- return rewriteValueAMD64_OpAMD64SHRQ_0(v)
+ return rewriteValueAMD64_OpAMD64SHRQ(v)
case OpAMD64SHRQconst:
- return rewriteValueAMD64_OpAMD64SHRQconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHRQconst(v)
case OpAMD64SHRW:
- return rewriteValueAMD64_OpAMD64SHRW_0(v)
+ return rewriteValueAMD64_OpAMD64SHRW(v)
case OpAMD64SHRWconst:
- return rewriteValueAMD64_OpAMD64SHRWconst_0(v)
+ return rewriteValueAMD64_OpAMD64SHRWconst(v)
case OpAMD64SUBL:
- return rewriteValueAMD64_OpAMD64SUBL_0(v)
+ return rewriteValueAMD64_OpAMD64SUBL(v)
case OpAMD64SUBLconst:
- return rewriteValueAMD64_OpAMD64SUBLconst_0(v)
+ return rewriteValueAMD64_OpAMD64SUBLconst(v)
case OpAMD64SUBLload:
- return rewriteValueAMD64_OpAMD64SUBLload_0(v)
+ return rewriteValueAMD64_OpAMD64SUBLload(v)
case OpAMD64SUBLmodify:
- return rewriteValueAMD64_OpAMD64SUBLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64SUBLmodify(v)
case OpAMD64SUBQ:
- return rewriteValueAMD64_OpAMD64SUBQ_0(v)
+ return rewriteValueAMD64_OpAMD64SUBQ(v)
case OpAMD64SUBQborrow:
- return rewriteValueAMD64_OpAMD64SUBQborrow_0(v)
+ return rewriteValueAMD64_OpAMD64SUBQborrow(v)
case OpAMD64SUBQconst:
- return rewriteValueAMD64_OpAMD64SUBQconst_0(v)
+ return rewriteValueAMD64_OpAMD64SUBQconst(v)
case OpAMD64SUBQload:
- return rewriteValueAMD64_OpAMD64SUBQload_0(v)
+ return rewriteValueAMD64_OpAMD64SUBQload(v)
case OpAMD64SUBQmodify:
- return rewriteValueAMD64_OpAMD64SUBQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64SUBQmodify(v)
case OpAMD64SUBSD:
- return rewriteValueAMD64_OpAMD64SUBSD_0(v)
+ return rewriteValueAMD64_OpAMD64SUBSD(v)
case OpAMD64SUBSDload:
- return rewriteValueAMD64_OpAMD64SUBSDload_0(v)
+ return rewriteValueAMD64_OpAMD64SUBSDload(v)
case OpAMD64SUBSS:
- return rewriteValueAMD64_OpAMD64SUBSS_0(v)
+ return rewriteValueAMD64_OpAMD64SUBSS(v)
case OpAMD64SUBSSload:
- return rewriteValueAMD64_OpAMD64SUBSSload_0(v)
+ return rewriteValueAMD64_OpAMD64SUBSSload(v)
case OpAMD64TESTB:
- return rewriteValueAMD64_OpAMD64TESTB_0(v)
+ return rewriteValueAMD64_OpAMD64TESTB(v)
case OpAMD64TESTBconst:
- return rewriteValueAMD64_OpAMD64TESTBconst_0(v)
+ return rewriteValueAMD64_OpAMD64TESTBconst(v)
case OpAMD64TESTL:
- return rewriteValueAMD64_OpAMD64TESTL_0(v)
+ return rewriteValueAMD64_OpAMD64TESTL(v)
case OpAMD64TESTLconst:
- return rewriteValueAMD64_OpAMD64TESTLconst_0(v)
+ return rewriteValueAMD64_OpAMD64TESTLconst(v)
case OpAMD64TESTQ:
- return rewriteValueAMD64_OpAMD64TESTQ_0(v)
+ return rewriteValueAMD64_OpAMD64TESTQ(v)
case OpAMD64TESTQconst:
- return rewriteValueAMD64_OpAMD64TESTQconst_0(v)
+ return rewriteValueAMD64_OpAMD64TESTQconst(v)
case OpAMD64TESTW:
- return rewriteValueAMD64_OpAMD64TESTW_0(v)
+ return rewriteValueAMD64_OpAMD64TESTW(v)
case OpAMD64TESTWconst:
- return rewriteValueAMD64_OpAMD64TESTWconst_0(v)
+ return rewriteValueAMD64_OpAMD64TESTWconst(v)
case OpAMD64XADDLlock:
- return rewriteValueAMD64_OpAMD64XADDLlock_0(v)
+ return rewriteValueAMD64_OpAMD64XADDLlock(v)
case OpAMD64XADDQlock:
- return rewriteValueAMD64_OpAMD64XADDQlock_0(v)
+ return rewriteValueAMD64_OpAMD64XADDQlock(v)
case OpAMD64XCHGL:
- return rewriteValueAMD64_OpAMD64XCHGL_0(v)
+ return rewriteValueAMD64_OpAMD64XCHGL(v)
case OpAMD64XCHGQ:
- return rewriteValueAMD64_OpAMD64XCHGQ_0(v)
+ return rewriteValueAMD64_OpAMD64XCHGQ(v)
case OpAMD64XORL:
- return rewriteValueAMD64_OpAMD64XORL_0(v)
+ return rewriteValueAMD64_OpAMD64XORL(v)
case OpAMD64XORLconst:
- return rewriteValueAMD64_OpAMD64XORLconst_0(v) || rewriteValueAMD64_OpAMD64XORLconst_10(v)
+ return rewriteValueAMD64_OpAMD64XORLconst(v)
case OpAMD64XORLconstmodify:
- return rewriteValueAMD64_OpAMD64XORLconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64XORLconstmodify(v)
case OpAMD64XORLload:
- return rewriteValueAMD64_OpAMD64XORLload_0(v)
+ return rewriteValueAMD64_OpAMD64XORLload(v)
case OpAMD64XORLmodify:
- return rewriteValueAMD64_OpAMD64XORLmodify_0(v)
+ return rewriteValueAMD64_OpAMD64XORLmodify(v)
case OpAMD64XORQ:
- return rewriteValueAMD64_OpAMD64XORQ_0(v)
+ return rewriteValueAMD64_OpAMD64XORQ(v)
case OpAMD64XORQconst:
- return rewriteValueAMD64_OpAMD64XORQconst_0(v)
+ return rewriteValueAMD64_OpAMD64XORQconst(v)
case OpAMD64XORQconstmodify:
- return rewriteValueAMD64_OpAMD64XORQconstmodify_0(v)
+ return rewriteValueAMD64_OpAMD64XORQconstmodify(v)
case OpAMD64XORQload:
- return rewriteValueAMD64_OpAMD64XORQload_0(v)
+ return rewriteValueAMD64_OpAMD64XORQload(v)
case OpAMD64XORQmodify:
- return rewriteValueAMD64_OpAMD64XORQmodify_0(v)
+ return rewriteValueAMD64_OpAMD64XORQmodify(v)
case OpAdd16:
v.Op = OpAMD64ADDL
return true
@@ -632,9 +632,9 @@
v.Op = OpAMD64ANDL
return true
case OpAtomicAdd32:
- return rewriteValueAMD64_OpAtomicAdd32_0(v)
+ return rewriteValueAMD64_OpAtomicAdd32(v)
case OpAtomicAdd64:
- return rewriteValueAMD64_OpAtomicAdd64_0(v)
+ return rewriteValueAMD64_OpAtomicAdd64(v)
case OpAtomicAnd8:
v.Op = OpAMD64ANDBlock
return true
@@ -645,9 +645,9 @@
v.Op = OpAMD64CMPXCHGQlock
return true
case OpAtomicExchange32:
- return rewriteValueAMD64_OpAtomicExchange32_0(v)
+ return rewriteValueAMD64_OpAtomicExchange32(v)
case OpAtomicExchange64:
- return rewriteValueAMD64_OpAtomicExchange64_0(v)
+ return rewriteValueAMD64_OpAtomicExchange64(v)
case OpAtomicLoad32:
v.Op = OpAMD64MOVLatomicload
return true
@@ -664,24 +664,24 @@
v.Op = OpAMD64ORBlock
return true
case OpAtomicStore32:
- return rewriteValueAMD64_OpAtomicStore32_0(v)
+ return rewriteValueAMD64_OpAtomicStore32(v)
case OpAtomicStore64:
- return rewriteValueAMD64_OpAtomicStore64_0(v)
+ return rewriteValueAMD64_OpAtomicStore64(v)
case OpAtomicStore8:
- return rewriteValueAMD64_OpAtomicStore8_0(v)
+ return rewriteValueAMD64_OpAtomicStore8(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v)
+ return rewriteValueAMD64_OpAtomicStorePtrNoWB(v)
case OpAvg64u:
v.Op = OpAMD64AVGQU
return true
case OpBitLen16:
- return rewriteValueAMD64_OpBitLen16_0(v)
+ return rewriteValueAMD64_OpBitLen16(v)
case OpBitLen32:
- return rewriteValueAMD64_OpBitLen32_0(v)
+ return rewriteValueAMD64_OpBitLen32(v)
case OpBitLen64:
- return rewriteValueAMD64_OpBitLen64_0(v)
+ return rewriteValueAMD64_OpBitLen64(v)
case OpBitLen8:
- return rewriteValueAMD64_OpBitLen8_0(v)
+ return rewriteValueAMD64_OpBitLen8(v)
case OpBswap32:
v.Op = OpAMD64BSWAPL
return true
@@ -689,7 +689,7 @@
v.Op = OpAMD64BSWAPQ
return true
case OpCeil:
- return rewriteValueAMD64_OpCeil_0(v)
+ return rewriteValueAMD64_OpCeil(v)
case OpClosureCall:
v.Op = OpAMD64CALLclosure
return true
@@ -706,7 +706,7 @@
v.Op = OpAMD64NOTL
return true
case OpCondSelect:
- return rewriteValueAMD64_OpCondSelect_0(v) || rewriteValueAMD64_OpCondSelect_10(v) || rewriteValueAMD64_OpCondSelect_20(v) || rewriteValueAMD64_OpCondSelect_30(v) || rewriteValueAMD64_OpCondSelect_40(v)
+ return rewriteValueAMD64_OpCondSelect(v)
case OpConst16:
v.Op = OpAMD64MOVLconst
return true
@@ -732,21 +732,21 @@
v.Op = OpAMD64MOVQconst
return true
case OpCtz16:
- return rewriteValueAMD64_OpCtz16_0(v)
+ return rewriteValueAMD64_OpCtz16(v)
case OpCtz16NonZero:
v.Op = OpAMD64BSFL
return true
case OpCtz32:
- return rewriteValueAMD64_OpCtz32_0(v)
+ return rewriteValueAMD64_OpCtz32(v)
case OpCtz32NonZero:
v.Op = OpAMD64BSFL
return true
case OpCtz64:
- return rewriteValueAMD64_OpCtz64_0(v)
+ return rewriteValueAMD64_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValueAMD64_OpCtz64NonZero_0(v)
+ return rewriteValueAMD64_OpCtz64NonZero(v)
case OpCtz8:
- return rewriteValueAMD64_OpCtz8_0(v)
+ return rewriteValueAMD64_OpCtz8(v)
case OpCtz8NonZero:
v.Op = OpAMD64BSFL
return true
@@ -784,67 +784,67 @@
v.Op = OpAMD64DIVQU2
return true
case OpDiv16:
- return rewriteValueAMD64_OpDiv16_0(v)
+ return rewriteValueAMD64_OpDiv16(v)
case OpDiv16u:
- return rewriteValueAMD64_OpDiv16u_0(v)
+ return rewriteValueAMD64_OpDiv16u(v)
case OpDiv32:
- return rewriteValueAMD64_OpDiv32_0(v)
+ return rewriteValueAMD64_OpDiv32(v)
case OpDiv32F:
v.Op = OpAMD64DIVSS
return true
case OpDiv32u:
- return rewriteValueAMD64_OpDiv32u_0(v)
+ return rewriteValueAMD64_OpDiv32u(v)
case OpDiv64:
- return rewriteValueAMD64_OpDiv64_0(v)
+ return rewriteValueAMD64_OpDiv64(v)
case OpDiv64F:
v.Op = OpAMD64DIVSD
return true
case OpDiv64u:
- return rewriteValueAMD64_OpDiv64u_0(v)
+ return rewriteValueAMD64_OpDiv64u(v)
case OpDiv8:
- return rewriteValueAMD64_OpDiv8_0(v)
+ return rewriteValueAMD64_OpDiv8(v)
case OpDiv8u:
- return rewriteValueAMD64_OpDiv8u_0(v)
+ return rewriteValueAMD64_OpDiv8u(v)
case OpEq16:
- return rewriteValueAMD64_OpEq16_0(v)
+ return rewriteValueAMD64_OpEq16(v)
case OpEq32:
- return rewriteValueAMD64_OpEq32_0(v)
+ return rewriteValueAMD64_OpEq32(v)
case OpEq32F:
- return rewriteValueAMD64_OpEq32F_0(v)
+ return rewriteValueAMD64_OpEq32F(v)
case OpEq64:
- return rewriteValueAMD64_OpEq64_0(v)
+ return rewriteValueAMD64_OpEq64(v)
case OpEq64F:
- return rewriteValueAMD64_OpEq64F_0(v)
+ return rewriteValueAMD64_OpEq64F(v)
case OpEq8:
- return rewriteValueAMD64_OpEq8_0(v)
+ return rewriteValueAMD64_OpEq8(v)
case OpEqB:
- return rewriteValueAMD64_OpEqB_0(v)
+ return rewriteValueAMD64_OpEqB(v)
case OpEqPtr:
- return rewriteValueAMD64_OpEqPtr_0(v)
+ return rewriteValueAMD64_OpEqPtr(v)
case OpFMA:
- return rewriteValueAMD64_OpFMA_0(v)
+ return rewriteValueAMD64_OpFMA(v)
case OpFloor:
- return rewriteValueAMD64_OpFloor_0(v)
+ return rewriteValueAMD64_OpFloor(v)
case OpGeq16:
- return rewriteValueAMD64_OpGeq16_0(v)
+ return rewriteValueAMD64_OpGeq16(v)
case OpGeq16U:
- return rewriteValueAMD64_OpGeq16U_0(v)
+ return rewriteValueAMD64_OpGeq16U(v)
case OpGeq32:
- return rewriteValueAMD64_OpGeq32_0(v)
+ return rewriteValueAMD64_OpGeq32(v)
case OpGeq32F:
- return rewriteValueAMD64_OpGeq32F_0(v)
+ return rewriteValueAMD64_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueAMD64_OpGeq32U_0(v)
+ return rewriteValueAMD64_OpGeq32U(v)
case OpGeq64:
- return rewriteValueAMD64_OpGeq64_0(v)
+ return rewriteValueAMD64_OpGeq64(v)
case OpGeq64F:
- return rewriteValueAMD64_OpGeq64F_0(v)
+ return rewriteValueAMD64_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueAMD64_OpGeq64U_0(v)
+ return rewriteValueAMD64_OpGeq64U(v)
case OpGeq8:
- return rewriteValueAMD64_OpGeq8_0(v)
+ return rewriteValueAMD64_OpGeq8(v)
case OpGeq8U:
- return rewriteValueAMD64_OpGeq8U_0(v)
+ return rewriteValueAMD64_OpGeq8U(v)
case OpGetCallerPC:
v.Op = OpAMD64LoweredGetCallerPC
return true
@@ -858,25 +858,25 @@
v.Op = OpAMD64LoweredGetG
return true
case OpGreater16:
- return rewriteValueAMD64_OpGreater16_0(v)
+ return rewriteValueAMD64_OpGreater16(v)
case OpGreater16U:
- return rewriteValueAMD64_OpGreater16U_0(v)
+ return rewriteValueAMD64_OpGreater16U(v)
case OpGreater32:
- return rewriteValueAMD64_OpGreater32_0(v)
+ return rewriteValueAMD64_OpGreater32(v)
case OpGreater32F:
- return rewriteValueAMD64_OpGreater32F_0(v)
+ return rewriteValueAMD64_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueAMD64_OpGreater32U_0(v)
+ return rewriteValueAMD64_OpGreater32U(v)
case OpGreater64:
- return rewriteValueAMD64_OpGreater64_0(v)
+ return rewriteValueAMD64_OpGreater64(v)
case OpGreater64F:
- return rewriteValueAMD64_OpGreater64F_0(v)
+ return rewriteValueAMD64_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueAMD64_OpGreater64U_0(v)
+ return rewriteValueAMD64_OpGreater64U(v)
case OpGreater8:
- return rewriteValueAMD64_OpGreater8_0(v)
+ return rewriteValueAMD64_OpGreater8(v)
case OpGreater8U:
- return rewriteValueAMD64_OpGreater8U_0(v)
+ return rewriteValueAMD64_OpGreater8U(v)
case OpHmul32:
v.Op = OpAMD64HMULL
return true
@@ -893,105 +893,105 @@
v.Op = OpAMD64CALLinter
return true
case OpIsInBounds:
- return rewriteValueAMD64_OpIsInBounds_0(v)
+ return rewriteValueAMD64_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueAMD64_OpIsNonNil_0(v)
+ return rewriteValueAMD64_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueAMD64_OpIsSliceInBounds_0(v)
+ return rewriteValueAMD64_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueAMD64_OpLeq16_0(v)
+ return rewriteValueAMD64_OpLeq16(v)
case OpLeq16U:
- return rewriteValueAMD64_OpLeq16U_0(v)
+ return rewriteValueAMD64_OpLeq16U(v)
case OpLeq32:
- return rewriteValueAMD64_OpLeq32_0(v)
+ return rewriteValueAMD64_OpLeq32(v)
case OpLeq32F:
- return rewriteValueAMD64_OpLeq32F_0(v)
+ return rewriteValueAMD64_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueAMD64_OpLeq32U_0(v)
+ return rewriteValueAMD64_OpLeq32U(v)
case OpLeq64:
- return rewriteValueAMD64_OpLeq64_0(v)
+ return rewriteValueAMD64_OpLeq64(v)
case OpLeq64F:
- return rewriteValueAMD64_OpLeq64F_0(v)
+ return rewriteValueAMD64_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueAMD64_OpLeq64U_0(v)
+ return rewriteValueAMD64_OpLeq64U(v)
case OpLeq8:
- return rewriteValueAMD64_OpLeq8_0(v)
+ return rewriteValueAMD64_OpLeq8(v)
case OpLeq8U:
- return rewriteValueAMD64_OpLeq8U_0(v)
+ return rewriteValueAMD64_OpLeq8U(v)
case OpLess16:
- return rewriteValueAMD64_OpLess16_0(v)
+ return rewriteValueAMD64_OpLess16(v)
case OpLess16U:
- return rewriteValueAMD64_OpLess16U_0(v)
+ return rewriteValueAMD64_OpLess16U(v)
case OpLess32:
- return rewriteValueAMD64_OpLess32_0(v)
+ return rewriteValueAMD64_OpLess32(v)
case OpLess32F:
- return rewriteValueAMD64_OpLess32F_0(v)
+ return rewriteValueAMD64_OpLess32F(v)
case OpLess32U:
- return rewriteValueAMD64_OpLess32U_0(v)
+ return rewriteValueAMD64_OpLess32U(v)
case OpLess64:
- return rewriteValueAMD64_OpLess64_0(v)
+ return rewriteValueAMD64_OpLess64(v)
case OpLess64F:
- return rewriteValueAMD64_OpLess64F_0(v)
+ return rewriteValueAMD64_OpLess64F(v)
case OpLess64U:
- return rewriteValueAMD64_OpLess64U_0(v)
+ return rewriteValueAMD64_OpLess64U(v)
case OpLess8:
- return rewriteValueAMD64_OpLess8_0(v)
+ return rewriteValueAMD64_OpLess8(v)
case OpLess8U:
- return rewriteValueAMD64_OpLess8U_0(v)
+ return rewriteValueAMD64_OpLess8U(v)
case OpLoad:
- return rewriteValueAMD64_OpLoad_0(v)
+ return rewriteValueAMD64_OpLoad(v)
case OpLocalAddr:
- return rewriteValueAMD64_OpLocalAddr_0(v)
+ return rewriteValueAMD64_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueAMD64_OpLsh16x16_0(v)
+ return rewriteValueAMD64_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueAMD64_OpLsh16x32_0(v)
+ return rewriteValueAMD64_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueAMD64_OpLsh16x64_0(v)
+ return rewriteValueAMD64_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueAMD64_OpLsh16x8_0(v)
+ return rewriteValueAMD64_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueAMD64_OpLsh32x16_0(v)
+ return rewriteValueAMD64_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueAMD64_OpLsh32x32_0(v)
+ return rewriteValueAMD64_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueAMD64_OpLsh32x64_0(v)
+ return rewriteValueAMD64_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueAMD64_OpLsh32x8_0(v)
+ return rewriteValueAMD64_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueAMD64_OpLsh64x16_0(v)
+ return rewriteValueAMD64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueAMD64_OpLsh64x32_0(v)
+ return rewriteValueAMD64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueAMD64_OpLsh64x64_0(v)
+ return rewriteValueAMD64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueAMD64_OpLsh64x8_0(v)
+ return rewriteValueAMD64_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueAMD64_OpLsh8x16_0(v)
+ return rewriteValueAMD64_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueAMD64_OpLsh8x32_0(v)
+ return rewriteValueAMD64_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueAMD64_OpLsh8x64_0(v)
+ return rewriteValueAMD64_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueAMD64_OpLsh8x8_0(v)
+ return rewriteValueAMD64_OpLsh8x8(v)
case OpMod16:
- return rewriteValueAMD64_OpMod16_0(v)
+ return rewriteValueAMD64_OpMod16(v)
case OpMod16u:
- return rewriteValueAMD64_OpMod16u_0(v)
+ return rewriteValueAMD64_OpMod16u(v)
case OpMod32:
- return rewriteValueAMD64_OpMod32_0(v)
+ return rewriteValueAMD64_OpMod32(v)
case OpMod32u:
- return rewriteValueAMD64_OpMod32u_0(v)
+ return rewriteValueAMD64_OpMod32u(v)
case OpMod64:
- return rewriteValueAMD64_OpMod64_0(v)
+ return rewriteValueAMD64_OpMod64(v)
case OpMod64u:
- return rewriteValueAMD64_OpMod64u_0(v)
+ return rewriteValueAMD64_OpMod64u(v)
case OpMod8:
- return rewriteValueAMD64_OpMod8_0(v)
+ return rewriteValueAMD64_OpMod8(v)
case OpMod8u:
- return rewriteValueAMD64_OpMod8u_0(v)
+ return rewriteValueAMD64_OpMod8u(v)
case OpMove:
- return rewriteValueAMD64_OpMove_0(v) || rewriteValueAMD64_OpMove_10(v) || rewriteValueAMD64_OpMove_20(v)
+ return rewriteValueAMD64_OpMove(v)
case OpMul16:
v.Op = OpAMD64MULL
return true
@@ -1020,38 +1020,38 @@
v.Op = OpAMD64NEGL
return true
case OpNeg32F:
- return rewriteValueAMD64_OpNeg32F_0(v)
+ return rewriteValueAMD64_OpNeg32F(v)
case OpNeg64:
v.Op = OpAMD64NEGQ
return true
case OpNeg64F:
- return rewriteValueAMD64_OpNeg64F_0(v)
+ return rewriteValueAMD64_OpNeg64F(v)
case OpNeg8:
v.Op = OpAMD64NEGL
return true
case OpNeq16:
- return rewriteValueAMD64_OpNeq16_0(v)
+ return rewriteValueAMD64_OpNeq16(v)
case OpNeq32:
- return rewriteValueAMD64_OpNeq32_0(v)
+ return rewriteValueAMD64_OpNeq32(v)
case OpNeq32F:
- return rewriteValueAMD64_OpNeq32F_0(v)
+ return rewriteValueAMD64_OpNeq32F(v)
case OpNeq64:
- return rewriteValueAMD64_OpNeq64_0(v)
+ return rewriteValueAMD64_OpNeq64(v)
case OpNeq64F:
- return rewriteValueAMD64_OpNeq64F_0(v)
+ return rewriteValueAMD64_OpNeq64F(v)
case OpNeq8:
- return rewriteValueAMD64_OpNeq8_0(v)
+ return rewriteValueAMD64_OpNeq8(v)
case OpNeqB:
- return rewriteValueAMD64_OpNeqB_0(v)
+ return rewriteValueAMD64_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueAMD64_OpNeqPtr_0(v)
+ return rewriteValueAMD64_OpNeqPtr(v)
case OpNilCheck:
v.Op = OpAMD64LoweredNilCheck
return true
case OpNot:
- return rewriteValueAMD64_OpNot_0(v)
+ return rewriteValueAMD64_OpNot(v)
case OpOffPtr:
- return rewriteValueAMD64_OpOffPtr_0(v)
+ return rewriteValueAMD64_OpOffPtr(v)
case OpOr16:
v.Op = OpAMD64ORL
return true
@@ -1068,9 +1068,9 @@
v.Op = OpAMD64ORL
return true
case OpPanicBounds:
- return rewriteValueAMD64_OpPanicBounds_0(v)
+ return rewriteValueAMD64_OpPanicBounds(v)
case OpPopCount16:
- return rewriteValueAMD64_OpPopCount16_0(v)
+ return rewriteValueAMD64_OpPopCount16(v)
case OpPopCount32:
v.Op = OpAMD64POPCNTL
return true
@@ -1078,7 +1078,7 @@
v.Op = OpAMD64POPCNTQ
return true
case OpPopCount8:
- return rewriteValueAMD64_OpPopCount8_0(v)
+ return rewriteValueAMD64_OpPopCount8(v)
case OpRotateLeft16:
v.Op = OpAMD64ROLW
return true
@@ -1098,75 +1098,75 @@
v.Op = OpCopy
return true
case OpRoundToEven:
- return rewriteValueAMD64_OpRoundToEven_0(v)
+ return rewriteValueAMD64_OpRoundToEven(v)
case OpRsh16Ux16:
- return rewriteValueAMD64_OpRsh16Ux16_0(v)
+ return rewriteValueAMD64_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueAMD64_OpRsh16Ux32_0(v)
+ return rewriteValueAMD64_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueAMD64_OpRsh16Ux64_0(v)
+ return rewriteValueAMD64_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueAMD64_OpRsh16Ux8_0(v)
+ return rewriteValueAMD64_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueAMD64_OpRsh16x16_0(v)
+ return rewriteValueAMD64_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueAMD64_OpRsh16x32_0(v)
+ return rewriteValueAMD64_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueAMD64_OpRsh16x64_0(v)
+ return rewriteValueAMD64_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueAMD64_OpRsh16x8_0(v)
+ return rewriteValueAMD64_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueAMD64_OpRsh32Ux16_0(v)
+ return rewriteValueAMD64_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueAMD64_OpRsh32Ux32_0(v)
+ return rewriteValueAMD64_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueAMD64_OpRsh32Ux64_0(v)
+ return rewriteValueAMD64_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueAMD64_OpRsh32Ux8_0(v)
+ return rewriteValueAMD64_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueAMD64_OpRsh32x16_0(v)
+ return rewriteValueAMD64_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueAMD64_OpRsh32x32_0(v)
+ return rewriteValueAMD64_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueAMD64_OpRsh32x64_0(v)
+ return rewriteValueAMD64_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueAMD64_OpRsh32x8_0(v)
+ return rewriteValueAMD64_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueAMD64_OpRsh64Ux16_0(v)
+ return rewriteValueAMD64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueAMD64_OpRsh64Ux32_0(v)
+ return rewriteValueAMD64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueAMD64_OpRsh64Ux64_0(v)
+ return rewriteValueAMD64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueAMD64_OpRsh64Ux8_0(v)
+ return rewriteValueAMD64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueAMD64_OpRsh64x16_0(v)
+ return rewriteValueAMD64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueAMD64_OpRsh64x32_0(v)
+ return rewriteValueAMD64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueAMD64_OpRsh64x64_0(v)
+ return rewriteValueAMD64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueAMD64_OpRsh64x8_0(v)
+ return rewriteValueAMD64_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueAMD64_OpRsh8Ux16_0(v)
+ return rewriteValueAMD64_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueAMD64_OpRsh8Ux32_0(v)
+ return rewriteValueAMD64_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueAMD64_OpRsh8Ux64_0(v)
+ return rewriteValueAMD64_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueAMD64_OpRsh8Ux8_0(v)
+ return rewriteValueAMD64_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueAMD64_OpRsh8x16_0(v)
+ return rewriteValueAMD64_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueAMD64_OpRsh8x32_0(v)
+ return rewriteValueAMD64_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueAMD64_OpRsh8x64_0(v)
+ return rewriteValueAMD64_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueAMD64_OpRsh8x8_0(v)
+ return rewriteValueAMD64_OpRsh8x8(v)
case OpSelect0:
- return rewriteValueAMD64_OpSelect0_0(v)
+ return rewriteValueAMD64_OpSelect0(v)
case OpSelect1:
- return rewriteValueAMD64_OpSelect1_0(v)
+ return rewriteValueAMD64_OpSelect1(v)
case OpSignExt16to32:
v.Op = OpAMD64MOVWQSX
return true
@@ -1186,7 +1186,7 @@
v.Op = OpAMD64MOVBQSX
return true
case OpSlicemask:
- return rewriteValueAMD64_OpSlicemask_0(v)
+ return rewriteValueAMD64_OpSlicemask(v)
case OpSqrt:
v.Op = OpAMD64SQRTSD
return true
@@ -1194,7 +1194,7 @@
v.Op = OpAMD64CALLstatic
return true
case OpStore:
- return rewriteValueAMD64_OpStore_0(v)
+ return rewriteValueAMD64_OpStore(v)
case OpSub16:
v.Op = OpAMD64SUBL
return true
@@ -1217,7 +1217,7 @@
v.Op = OpAMD64SUBQ
return true
case OpTrunc:
- return rewriteValueAMD64_OpTrunc_0(v)
+ return rewriteValueAMD64_OpTrunc(v)
case OpTrunc16to8:
v.Op = OpCopy
return true
@@ -1252,7 +1252,7 @@
v.Op = OpAMD64XORL
return true
case OpZero:
- return rewriteValueAMD64_OpZero_0(v) || rewriteValueAMD64_OpZero_10(v) || rewriteValueAMD64_OpZero_20(v)
+ return rewriteValueAMD64_OpZero(v)
case OpZeroExt16to32:
v.Op = OpAMD64MOVWQZX
return true
@@ -1274,7 +1274,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADCQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADCQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1315,7 +1315,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADCQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADCQconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADCQconst x [c] (FlagEQ))
@@ -1333,7 +1333,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDL x (MOVLconst [c]))
@@ -1535,11 +1535,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (ADDL x (LEAL [c] {s} y))
// cond: x.Op != OpSB && y.Op != OpSB
// result: (LEAL1 [c] {s} x y)
@@ -1609,7 +1604,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDLconst [c] (ADDL x y))
// result: (LEAL1 [c] x y)
@@ -1788,10 +1783,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ADDLconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (ADDLconst [off] x:(SP))
// result: (LEAL [off] x)
for {
@@ -1807,7 +1798,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -1857,7 +1848,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1936,7 +1927,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1991,7 +1982,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDQ x (MOVQconst [c]))
@@ -2187,11 +2178,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (ADDQ x l:(MOVQload [off] {sym} ptr mem))
// cond: canMergeLoadClobber(v, l, x) && clobber(l)
// result: (ADDQload x [off] {sym} ptr mem)
@@ -2221,7 +2207,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQcarry_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQcarry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDQcarry x (MOVQconst [c]))
@@ -2246,7 +2232,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDQconst [c] (ADDQ x y))
// result: (LEAQ1 [c] x y)
@@ -2427,10 +2413,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ADDQconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (ADDQconst [off] x:(SP))
// result: (LEAQ [off] x)
for {
@@ -2446,7 +2428,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -2496,7 +2478,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2575,7 +2557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2630,7 +2612,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -2662,7 +2644,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSDload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2741,7 +2723,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -2773,7 +2755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSSload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2852,7 +2834,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDL (NOTL (SHLL (MOVLconst [1]) y)) x)
@@ -2956,7 +2938,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDLconst [c] x)
// cond: isUint32PowerOfTwo(^c) && uint64(^c) >= 128
@@ -3062,7 +3044,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -3112,7 +3094,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3191,7 +3173,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3246,7 +3228,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDQ (NOTQ (SHLQ (MOVQconst [1]) y)) x)
@@ -3354,7 +3336,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDQconst [c] x)
// cond: isUint64PowerOfTwo(^c) && uint64(^c) >= 128
@@ -3467,7 +3449,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -3517,7 +3499,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3596,7 +3578,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3651,7 +3633,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x)))
@@ -3700,7 +3682,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTCLconst [c] (XORLconst [d] x))
// result: (XORLconst [d ^ 1<<uint32(c)] x)
@@ -3744,7 +3726,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTCLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -3794,7 +3776,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3849,7 +3831,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTCQconst [c] (XORQconst [d] x))
// result: (XORQconst [d ^ 1<<uint32(c)] x)
@@ -3893,7 +3875,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTCQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -3943,7 +3925,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTCQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTCQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3998,7 +3980,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTLconst [c] (SHRQconst [d] x))
// cond: (c+d)<64
@@ -4108,7 +4090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTQconst [c] (SHRQconst [d] x))
// cond: (c+d)<64
@@ -4165,7 +4147,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTRLconst [c] (BTSLconst [c] x))
// result: (BTRLconst [c] x)
@@ -4235,7 +4217,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTRLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -4285,7 +4267,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4340,7 +4322,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTRQconst [c] (BTSQconst [c] x))
// result: (BTRQconst [c] x)
@@ -4410,7 +4392,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTRQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -4460,7 +4442,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTRQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTRQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4515,7 +4497,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTSLconst [c] (BTRLconst [c] x))
// result: (BTSLconst [c] x)
@@ -4585,7 +4567,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTSLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -4635,7 +4617,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4690,7 +4672,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BTSQconst [c] (BTRQconst [c] x))
// result: (BTSQconst [c] x)
@@ -4760,7 +4742,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BTSQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -4810,7 +4792,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64BTSQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTSQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4865,7 +4847,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLCC_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLCC(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4946,7 +4928,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLCS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLCS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5027,7 +5009,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLEQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLEQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5108,7 +5090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLGE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLGE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5189,7 +5171,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLGT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLGT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5270,7 +5252,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLHI_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLHI(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5351,7 +5333,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLLE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5432,7 +5414,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLLS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5513,7 +5495,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLLT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLLT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5594,7 +5576,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVLNE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVLNE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5675,7 +5657,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQCC_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQCC(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5756,7 +5738,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQCS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQCS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5837,7 +5819,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQEQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5943,7 +5925,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQGE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQGE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6024,7 +6006,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQGT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQGT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6105,7 +6087,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQHI_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQHI(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6186,7 +6168,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQLE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6267,7 +6249,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQLS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6348,7 +6330,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQLT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQLT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6429,7 +6411,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQNE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQNE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6510,7 +6492,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWCC_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWCC(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6591,7 +6573,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWCS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWCS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6672,7 +6654,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWEQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWEQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6753,7 +6735,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWGE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWGE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6834,7 +6816,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWGT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWGT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6915,7 +6897,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWHI_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWHI(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6996,7 +6978,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWLE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7077,7 +7059,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWLS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7158,7 +7140,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWLT_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWLT(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7239,7 +7221,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVWNE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVWNE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7320,7 +7302,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7404,7 +7386,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPBconst (MOVLconst [x]) [y])
@@ -7563,7 +7545,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconstload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPBconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -7613,7 +7595,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7690,7 +7672,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7774,8 +7756,9 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
@@ -7919,11 +7902,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64CMPLconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (CMPLconst l:(MOVLload {sym} [off] ptr mem) [c])
// cond: l.Uses == 1 && validValAndOff(c, off) && clobber(l)
// result: @l.Block (CMPLconstload {sym} [makeValAndOff(c,off)] ptr mem)
@@ -7952,7 +7930,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconstload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPLconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -8002,7 +7980,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8079,7 +8057,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8171,8 +8149,9 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
// match: (CMPQconst (NEGQ (ADDQconst [-16] (ANDQconst [15] _))) [32])
// result: (FlagLT_ULT)
for {
@@ -8315,11 +8294,6 @@
v.reset(OpAMD64FlagLT_ULT)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64CMPQconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (CMPQconst (SHRQconst _ [c]) [n])
// cond: 0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)
// result: (FlagLT_ULT)
@@ -8431,7 +8405,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconstload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPQconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -8481,7 +8455,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8558,7 +8532,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8642,7 +8616,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (CMPWconst (MOVLconst [x]) [y])
@@ -8801,7 +8775,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconstload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPWconstload [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -8851,7 +8825,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8928,7 +8902,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -8961,7 +8935,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -8994,7 +8968,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSD_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64DIVSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -9023,7 +8997,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSDload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64DIVSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9078,7 +9052,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64DIVSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -9107,7 +9081,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64DIVSSload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64DIVSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9162,7 +9136,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64HMULL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULL x y)
@@ -9181,7 +9155,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULLU_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64HMULLU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULLU x y)
@@ -9200,7 +9174,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64HMULQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULQ x y)
@@ -9219,7 +9193,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64HMULQU_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64HMULQU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (HMULQU x y)
@@ -9238,7 +9212,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool {
v_0 := v.Args[0]
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
@@ -9289,7 +9263,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL1(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
@@ -9379,7 +9353,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL2_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL2(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
@@ -9462,7 +9436,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL4(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
@@ -9528,7 +9502,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
@@ -9577,7 +9551,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool {
v_0 := v.Args[0]
// match: (LEAQ [c] {s} (ADDQconst [d] x))
// cond: is32Bit(c+d)
@@ -9741,7 +9715,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
@@ -9857,7 +9831,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ2_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
@@ -9963,7 +9937,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
@@ -10052,7 +10026,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
@@ -10124,7 +10098,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem))
@@ -10257,7 +10231,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSXload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBQSXload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
@@ -10307,7 +10281,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQZX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem))
@@ -10476,7 +10450,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBatomicload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBatomicload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -10526,7 +10500,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
@@ -10710,7 +10684,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10795,10 +10769,12 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVBstore [off] {sym} ptr y:(SETL x) mem)
// cond: y.Uses == 1
// result: (SETLstore [off] {sym} ptr x mem)
@@ -11039,13 +11015,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVBstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
// result: (MOVBstore [off] {sym} ptr x mem)
for {
@@ -11320,14 +11289,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVBstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVBstore [i] {s} p w x6:(MOVBstore [i-1] {s} p (SHRQconst [8] w) x5:(MOVBstore [i-2] {s} p (SHRQconst [16] w) x4:(MOVBstore [i-3] {s} p (SHRQconst [24] w) x3:(MOVBstore [i-4] {s} p (SHRQconst [32] w) x2:(MOVBstore [i-5] {s} p (SHRQconst [40] w) x1:(MOVBstore [i-6] {s} p (SHRQconst [48] w) x0:(MOVBstore [i-7] {s} p (SHRQconst [56] w) mem))))))))
// cond: x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses == 1 && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(x4) && clobber(x5) && clobber(x6)
// result: (MOVQstore [i-7] {s} p (BSWAPQ <w.Type> w) mem)
@@ -11703,12 +11664,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVBstore_30(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVBstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2) && is32Bit(off1+off2)
// result: (MOVBstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
@@ -11760,7 +11715,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -11951,7 +11906,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12046,7 +12001,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12546,13 +12501,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVBstoreidx1_10(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVBstoreidx1 [i] {s} p (MOVQconst [c]) w mem)
// cond: is32Bit(i+c)
// result: (MOVBstore [i+c] {s} p w mem)
@@ -12582,7 +12530,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem))
@@ -12687,7 +12635,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSXload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVLQSXload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
@@ -12737,7 +12685,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem))
@@ -12905,7 +12853,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLatomicload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -12955,7 +12903,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLf2i_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLf2i(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLf2i <t> (Arg <u> [off] {sym}))
@@ -12982,7 +12930,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLi2f_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLi2f(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVLi2f <t> (Arg <u> [off] {sym}))
@@ -13009,9 +12957,11 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ config := b.Func.Config
// match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVLQZX x)
@@ -13246,12 +13196,6 @@
v.AddArg(val)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVLload_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
// match: (MOVLload [off] {sym} (SB) _)
// cond: symIsRO(sym)
// result: (MOVQconst [int64(read32(sym, off, config.BigEndian))])
@@ -13267,7 +13211,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13396,7 +13340,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13472,7 +13416,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13548,10 +13492,12 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
// result: (MOVLstore [off] {sym} ptr x mem)
for {
@@ -13795,14 +13741,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVLstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVLstore [i] {s} p (SHRQconst [32] w) x:(MOVLstore [i-4] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVQstore [i-4] {s} p w mem)
@@ -14088,12 +14026,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVLstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVLstore {sym} [off] ptr y:(SUBL l:(MOVLload [off] {sym} ptr mem) x) mem)
// cond: y.Uses==1 && l.Uses==1 && clobber(y) && clobber(l)
// result: (SUBLmodify [off] {sym} ptr x mem)
@@ -14401,12 +14333,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVLstore_30(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVLstore [off] {sym} ptr a:(XORLconst [c] l:(MOVLload [off] {sym} ptr2 mem)) mem)
// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(c,off) && clobber(l) && clobber(a)
// result: (XORLconstmodify {sym} [makeValAndOff(c,off)] ptr mem)
@@ -14540,7 +14466,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14764,7 +14690,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14886,7 +14812,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14976,7 +14902,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -15193,7 +15119,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -15346,7 +15272,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx8(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -15429,7 +15355,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -15479,7 +15405,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15534,7 +15460,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQatomicload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -15584,7 +15510,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQf2i_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQf2i(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVQf2i <t> (Arg <u> [off] {sym}))
@@ -15611,7 +15537,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQi2f_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQi2f(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVQi2f <t> (Arg <u> [off] {sym}))
@@ -15638,7 +15564,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15868,7 +15794,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15975,7 +15901,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16051,7 +15977,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16308,12 +16234,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVQstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVQstore {sym} [off] ptr y:(ORQload x [off] {sym} ptr mem) mem)
// cond: y.Uses==1 && clobber(y)
// result: (ORQmodify [off] {sym} ptr x mem)
@@ -16622,12 +16542,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVQstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVQstore [off] {sym} ptr a:(ADDQconst [c] l:(MOVQload [off] {sym} ptr2 mem)) mem)
// cond: isSamePtr(ptr, ptr2) && a.Uses == 1 && l.Uses == 1 && validValAndOff(c,off) && clobber(l) && clobber(a)
// result: (ADDQconstmodify {sym} [makeValAndOff(c,off)] ptr mem)
@@ -16845,7 +16759,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17040,7 +16954,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17122,7 +17036,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17176,7 +17090,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -17292,7 +17206,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -17375,7 +17289,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -17522,7 +17436,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17617,7 +17531,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17693,7 +17607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17852,7 +17766,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -17956,7 +17870,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -18039,7 +17953,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
@@ -18186,7 +18100,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18281,7 +18195,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18357,7 +18271,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18516,7 +18430,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -18620,7 +18534,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -18703,7 +18617,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem))
@@ -18822,7 +18736,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSXload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWQSXload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
@@ -18872,7 +18786,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem))
@@ -19054,7 +18968,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19265,7 +19179,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19372,7 +19286,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19448,10 +19362,12 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
// result: (MOVWstore [off] {sym} ptr x mem)
for {
@@ -19695,14 +19611,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MOVWstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVWstore [i] {s} p (SHRQconst [16] w) x:(MOVWstore [i-2] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVLstore [i-2] {s} p w mem)
@@ -19889,7 +19797,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
@@ -20105,7 +20013,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20222,7 +20130,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20308,7 +20216,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -20578,7 +20486,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -20763,7 +20671,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULL x (MOVLconst [c]))
@@ -20784,7 +20692,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLconst [c] (MULLconst [d] x))
@@ -20915,11 +20823,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULLconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULLconst [ 9] x)
// result: (LEAL8 x x)
for {
@@ -21073,11 +20976,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULLconst_20(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULLconst [73] x)
// result: (LEAL8 x (LEAL8 <v.Type> x x))
for {
@@ -21247,10 +21145,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULLconst_30(v *Value) bool {
- v_0 := v.Args[0]
// match: (MULLconst [c] (MOVLconst [d]))
// result: (MOVLconst [int64(int32(c*d))])
for {
@@ -21265,7 +21159,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULQ x (MOVQconst [c]))
@@ -21290,7 +21184,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULQconst [c] (MULQconst [d] x))
@@ -21425,11 +21319,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULQconst_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULQconst [ 9] x)
// result: (LEAQ8 x x)
for {
@@ -21583,11 +21472,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULQconst_20(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MULQconst [73] x)
// result: (LEAQ8 x (LEAQ8 <v.Type> x x))
for {
@@ -21757,10 +21641,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64MULQconst_30(v *Value) bool {
- v_0 := v.Args[0]
// match: (MULQconst [c] (MOVQconst [d]))
// result: (MOVQconst [c*d])
for {
@@ -21792,7 +21672,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -21824,7 +21704,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSDload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21903,7 +21783,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -21935,7 +21815,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSSload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -22014,7 +21894,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGL (NEGL x))
// result: x
@@ -22059,7 +21939,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGQ (NEGQ x))
// result: x
@@ -22125,7 +22005,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool {
v_0 := v.Args[0]
// match: (NOTL (MOVLconst [c]))
// result: (MOVLconst [^c])
@@ -22140,7 +22020,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool {
v_0 := v.Args[0]
// match: (NOTQ (MOVQconst [c]))
// result: (MOVQconst [^c])
@@ -22155,9 +22035,11 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (ORL (SHLL (MOVLconst [1]) y) x)
// result: (BTSL x y)
for {
@@ -22492,13 +22374,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORL (SHLL x (ANDQconst y [15])) (ANDL (SHRW x (NEGQ (ADDQconst (ANDQconst y [15]) [-16]))) (SBBLcarrymask (CMPQconst (NEGQ (ADDQconst (ANDQconst y [15]) [-16])) [16]))))
// cond: v.Type.Size() == 2
// result: (ROLW x y)
@@ -22976,13 +22851,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORL x0:(MOVWload [i0] {s} p mem) sh:(SHLLconst [16] x1:(MOVWload [i1] {s} 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) (MOVLload [i0] {s} p mem)
@@ -23547,13 +23415,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORL s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)) or:(ORL s1:(SHLLconst [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,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1,y) (ORL <v.Type> (SHLLconst <v.Type> [j1] (ROLWconst <typ.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
@@ -23662,7 +23523,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORLconst [c] x)
// cond: isUint32PowerOfTwo(c) && uint64(c) >= 128
@@ -23746,7 +23607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -23796,7 +23657,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23875,7 +23736,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23930,7 +23791,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24276,13 +24137,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORQ x0:(MOVWload [i0] {s} p mem) sh:(SHLQconst [16] x1:(MOVWload [i1] {s} 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) (MOVLload [i0] {s} p mem)
@@ -24846,13 +24700,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORQ r1:(ROLWconst [8] x1:(MOVWload [i1] {s} p mem)) sh:(SHLQconst [16] r0:(ROLWconst [8] x0:(MOVWload [i0] {s} 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> (MOVLload [i0] {s} p mem))
@@ -25470,7 +25317,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORQconst [c] x)
// cond: isUint64PowerOfTwo(c) && uint64(c) >= 128
@@ -25550,7 +25397,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -25600,7 +25447,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25679,7 +25526,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -25734,7 +25581,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLB x (NEGQ y))
@@ -25791,7 +25638,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLBconst [c] (ROLBconst [d] x))
// result: (ROLBconst [(c+d)& 7] x)
@@ -25821,7 +25668,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLL x (NEGQ y))
@@ -25878,7 +25725,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLLconst [c] (ROLLconst [d] x))
// result: (ROLLconst [(c+d)&31] x)
@@ -25908,7 +25755,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLQ x (NEGQ y))
@@ -25965,7 +25812,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLQconst [c] (ROLQconst [d] x))
// result: (ROLQconst [(c+d)&63] x)
@@ -25995,7 +25842,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROLW x (NEGQ y))
@@ -26052,7 +25899,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ROLWconst [c] (ROLWconst [d] x))
// result: (ROLWconst [(c+d)&15] x)
@@ -26082,7 +25929,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORB x (NEGQ y))
@@ -26139,7 +25986,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORL x (NEGQ y))
@@ -26196,7 +26043,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORQ x (NEGQ y))
@@ -26253,7 +26100,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RORW x (NEGQ y))
@@ -26310,7 +26157,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARB x (MOVQconst [c]))
@@ -26341,7 +26188,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARBconst x [0])
// result: x
@@ -26369,7 +26216,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26573,7 +26420,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARLconst x [0])
// result: x
@@ -26601,7 +26448,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26805,7 +26652,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARQconst x [0])
// result: x
@@ -26833,7 +26680,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SARW x (MOVQconst [c]))
@@ -26864,7 +26711,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SARWconst x [0])
// result: x
@@ -26892,7 +26739,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool {
v_0 := v.Args[0]
// match: (SBBLcarrymask (FlagEQ))
// result: (MOVLconst [0])
@@ -26946,7 +26793,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -26984,7 +26831,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool {
v_0 := v.Args[0]
// match: (SBBQcarrymask (FlagEQ))
// result: (MOVQconst [0])
@@ -27038,7 +26885,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SBBQconst x [c] (FlagEQ))
@@ -27056,7 +26903,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETA(v *Value) bool {
v_0 := v.Args[0]
// match: (SETA (InvertFlags x))
// result: (SETB x)
@@ -27121,7 +26968,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETAE (InvertFlags x))
// result: (SETBE x)
@@ -27186,7 +27033,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAEstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAEstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -27362,7 +27209,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -27538,7 +27385,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
v_0 := v.Args[0]
// match: (SETB (InvertFlags x))
// result: (SETA x)
@@ -27603,7 +27450,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETBE (InvertFlags x))
// result: (SETAE x)
@@ -27668,7 +27515,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBEstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBEstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -27844,7 +27691,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -28020,7 +27867,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETEQ (TESTL (SHLL (MOVLconst [1]) x) y))
@@ -28278,11 +28125,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (SETEQ (TESTL z1:(SHRLconst [31] (SHLLconst [31] x)) z2))
// cond: z1==z2
// result: (SETAE (BTLconst [0] x))
@@ -28437,11 +28279,12 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETEQstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (SETEQstore [off] {sym} ptr (TESTL (SHLL (MOVLconst [1]) x) y) mem)
// result: (SETAEstore [off] {sym} ptr (BTL x y) mem)
for {
@@ -28777,14 +28620,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETEQstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (SETEQstore [off] {sym} ptr (TESTL z1:(SHRLconst [31] (SHLLconst [31] x)) z2) mem)
// cond: z1==z2
// result: (SETAEstore [off] {sym} ptr (BTLconst [0] x) mem)
@@ -29048,14 +28883,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETEQstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (SETEQstore [off] {sym} ptr (FlagGT_UGT) mem)
// result: (MOVBstore [off] {sym} ptr (MOVLconst <typ.UInt8> [0]) mem)
for {
@@ -29078,7 +28905,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETG(v *Value) bool {
v_0 := v.Args[0]
// match: (SETG (InvertFlags x))
// result: (SETL x)
@@ -29143,7 +28970,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETGE (InvertFlags x))
// result: (SETLE x)
@@ -29208,7 +29035,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGEstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGEstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29384,7 +29211,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29560,7 +29387,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETL(v *Value) bool {
v_0 := v.Args[0]
// match: (SETL (InvertFlags x))
// result: (SETG x)
@@ -29625,7 +29452,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool {
v_0 := v.Args[0]
// match: (SETLE (InvertFlags x))
// result: (SETGE x)
@@ -29690,7 +29517,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLEstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLEstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -29866,7 +29693,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -30042,7 +29869,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SETNE (TESTL (SHLL (MOVLconst [1]) x) y))
@@ -30300,11 +30127,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (SETNE (TESTL z1:(SHRLconst [31] (SHLLconst [31] x)) z2))
// cond: z1==z2
// result: (SETB (BTLconst [0] x))
@@ -30459,11 +30281,12 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNEstore_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETNEstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (SETNEstore [off] {sym} ptr (TESTL (SHLL (MOVLconst [1]) x) y) mem)
// result: (SETBstore [off] {sym} ptr (BTL x y) mem)
for {
@@ -30799,14 +30622,6 @@
}
break
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETNEstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (SETNEstore [off] {sym} ptr (TESTL z1:(SHRLconst [31] (SHLLconst [31] x)) z2) mem)
// cond: z1==z2
// result: (SETBstore [off] {sym} ptr (BTLconst [0] x) mem)
@@ -31070,14 +30885,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64SETNEstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (SETNEstore [off] {sym} ptr (FlagGT_UGT) mem)
// result: (MOVBstore [off] {sym} ptr (MOVLconst <typ.UInt8> [1]) mem)
for {
@@ -31100,7 +30907,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31304,7 +31111,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHLLconst [1] (SHRLconst [1] x))
// result: (BTRLconst [0] x)
@@ -31332,7 +31139,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31536,7 +31343,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHLQconst [1] (SHRQconst [1] x))
// result: (BTRQconst [0] x)
@@ -31564,7 +31371,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRB x (MOVQconst [c]))
@@ -31633,7 +31440,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRBconst x [0])
// result: x
@@ -31649,7 +31456,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -31853,7 +31660,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRLconst [1] (SHLLconst [1] x))
// result: (BTRLconst [31] x)
@@ -31881,7 +31688,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32085,7 +31892,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRQconst [1] (SHLQconst [1] x))
// result: (BTRQconst [63] x)
@@ -32113,7 +31920,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SHRW x (MOVQconst [c]))
@@ -32182,7 +31989,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SHRWconst x [0])
// result: x
@@ -32198,7 +32005,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32267,7 +32074,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
@@ -32294,7 +32101,7 @@
return true
}
}
-func rewriteValueAMD64_OpAMD64SUBLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32373,7 +32180,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32428,7 +32235,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32505,7 +32312,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQborrow_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQborrow(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBQborrow x (MOVQconst [c]))
@@ -32527,7 +32334,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBQconst [0] x)
// result: x
@@ -32587,7 +32394,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32666,7 +32473,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32721,7 +32528,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
@@ -32750,7 +32557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSDload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32829,7 +32636,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
@@ -32858,7 +32665,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSSload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSSload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -32937,7 +32744,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -32988,7 +32795,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTBconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TESTBconst [-1] x)
// cond: x.Op != OpAMD64MOVLconst
@@ -33008,7 +32815,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33059,7 +32866,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TESTLconst [-1] x)
// cond: x.Op != OpAMD64MOVLconst
@@ -33079,7 +32886,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33134,7 +32941,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TESTQconst [-1] x)
// cond: x.Op != OpAMD64MOVQconst
@@ -33154,7 +32961,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -33205,7 +33012,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTWconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TESTWconst [-1] x)
// cond: x.Op != OpAMD64MOVLconst
@@ -33225,7 +33032,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33255,7 +33062,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33285,7 +33092,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33340,7 +33147,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33395,7 +33202,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORL (SHLL (MOVLconst [1]) y) x)
@@ -33568,7 +33375,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORLconst [c] x)
// cond: isUint32PowerOfTwo(c) && uint64(c) >= 128
@@ -33683,10 +33490,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueAMD64_OpAMD64XORLconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (XORLconst [1] (SETA x))
// result: (SETBE x)
for {
@@ -33754,7 +33557,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORLconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -33804,7 +33607,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33883,7 +33686,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -33938,7 +33741,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORQ (SHLQ (MOVQconst [1]) y) x)
@@ -34065,7 +33868,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORQconst [c] x)
// cond: isUint64PowerOfTwo(c) && uint64(c) >= 128
@@ -34135,7 +33938,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconstmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQconstmodify(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORQconstmodify [valoff1] {sym} (ADDQconst [off2] base) mem)
@@ -34185,7 +33988,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQload_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34264,7 +34067,7 @@
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQmodify_0(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQmodify(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34319,7 +34122,7 @@
}
return false
}
-func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34341,7 +34144,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34363,7 +34166,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34380,7 +34183,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34397,7 +34200,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34418,7 +34221,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34439,7 +34242,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34460,7 +34263,7 @@
return true
}
}
-func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -34481,7 +34284,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen16_0(v *Value) bool {
+func rewriteValueAMD64_OpBitLen16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -34502,7 +34305,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen32_0(v *Value) bool {
+func rewriteValueAMD64_OpBitLen32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -34525,7 +34328,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen64_0(v *Value) bool {
+func rewriteValueAMD64_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -34554,7 +34357,7 @@
return true
}
}
-func rewriteValueAMD64_OpBitLen8_0(v *Value) bool {
+func rewriteValueAMD64_OpBitLen8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -34575,7 +34378,7 @@
return true
}
}
-func rewriteValueAMD64_OpCeil_0(v *Value) bool {
+func rewriteValueAMD64_OpCeil(v *Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (ROUNDSD [2] x)
@@ -34587,10 +34390,12 @@
return true
}
}
-func rewriteValueAMD64_OpCondSelect_0(v *Value) bool {
+func rewriteValueAMD64_OpCondSelect(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (CondSelect <t> x y (SETEQ cond))
// cond: (is64BitInt(t) || isPtr(t))
// result: (CMOVQEQ y x cond)
@@ -34791,12 +34596,6 @@
v.AddArg(cond)
return true
}
- return false
-}
-func rewriteValueAMD64_OpCondSelect_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (CondSelect <t> x y (SETEQF cond))
// cond: (is64BitInt(t) || isPtr(t))
// result: (CMOVQEQF y x cond)
@@ -34997,12 +34796,6 @@
v.AddArg(cond)
return true
}
- return false
-}
-func rewriteValueAMD64_OpCondSelect_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (CondSelect <t> x y (SETA cond))
// cond: is32BitInt(t)
// result: (CMOVLHI y x cond)
@@ -35203,12 +34996,6 @@
v.AddArg(cond)
return true
}
- return false
-}
-func rewriteValueAMD64_OpCondSelect_30(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (CondSelect <t> x y (SETL cond))
// cond: is16BitInt(t)
// result: (CMOVWLT y x cond)
@@ -35409,14 +35196,6 @@
v.AddArg(cond)
return true
}
- return false
-}
-func rewriteValueAMD64_OpCondSelect_40(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (CondSelect <t> x y (SETGF cond))
// cond: is16BitInt(t)
// result: (CMOVWGTF y x cond)
@@ -35579,7 +35358,7 @@
}
return false
}
-func rewriteValueAMD64_OpCtz16_0(v *Value) bool {
+func rewriteValueAMD64_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -35595,7 +35374,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz32_0(v *Value) bool {
+func rewriteValueAMD64_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -35613,7 +35392,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz64_0(v *Value) bool {
+func rewriteValueAMD64_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -35639,7 +35418,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValueAMD64_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -35654,7 +35433,7 @@
return true
}
}
-func rewriteValueAMD64_OpCtz8_0(v *Value) bool {
+func rewriteValueAMD64_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -35670,7 +35449,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35690,7 +35469,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv16u_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35708,7 +35487,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35728,7 +35507,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv32u_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35746,7 +35525,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35766,7 +35545,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv64u_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35784,7 +35563,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35806,7 +35585,7 @@
return true
}
}
-func rewriteValueAMD64_OpDiv8u_0(v *Value) bool {
+func rewriteValueAMD64_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35828,7 +35607,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq16_0(v *Value) bool {
+func rewriteValueAMD64_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35845,7 +35624,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32_0(v *Value) bool {
+func rewriteValueAMD64_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35862,7 +35641,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq32F_0(v *Value) bool {
+func rewriteValueAMD64_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35879,7 +35658,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64_0(v *Value) bool {
+func rewriteValueAMD64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35896,7 +35675,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq64F_0(v *Value) bool {
+func rewriteValueAMD64_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35913,7 +35692,7 @@
return true
}
}
-func rewriteValueAMD64_OpEq8_0(v *Value) bool {
+func rewriteValueAMD64_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35930,7 +35709,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqB_0(v *Value) bool {
+func rewriteValueAMD64_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35947,7 +35726,7 @@
return true
}
}
-func rewriteValueAMD64_OpEqPtr_0(v *Value) bool {
+func rewriteValueAMD64_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -35964,7 +35743,7 @@
return true
}
}
-func rewriteValueAMD64_OpFMA_0(v *Value) bool {
+func rewriteValueAMD64_OpFMA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -35981,7 +35760,7 @@
return true
}
}
-func rewriteValueAMD64_OpFloor_0(v *Value) bool {
+func rewriteValueAMD64_OpFloor(v *Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (ROUNDSD [1] x)
@@ -35993,7 +35772,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq16_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36010,7 +35789,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq16U_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36027,7 +35806,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36044,7 +35823,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32F_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36061,7 +35840,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq32U_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36078,7 +35857,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36095,7 +35874,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64F_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36112,7 +35891,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq64U_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36129,7 +35908,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq8_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36146,7 +35925,7 @@
return true
}
}
-func rewriteValueAMD64_OpGeq8U_0(v *Value) bool {
+func rewriteValueAMD64_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36163,7 +35942,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater16_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36180,7 +35959,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater16U_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36197,7 +35976,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36214,7 +35993,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32F_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36231,7 +36010,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater32U_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36248,7 +36027,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36265,7 +36044,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64F_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36282,7 +36061,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater64U_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36299,7 +36078,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater8_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36316,7 +36095,7 @@
return true
}
}
-func rewriteValueAMD64_OpGreater8U_0(v *Value) bool {
+func rewriteValueAMD64_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36333,7 +36112,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool {
+func rewriteValueAMD64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36350,7 +36129,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool {
+func rewriteValueAMD64_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil p)
@@ -36365,7 +36144,7 @@
return true
}
}
-func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36382,7 +36161,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36399,7 +36178,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq16U_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36416,7 +36195,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36433,7 +36212,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32F_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36450,7 +36229,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq32U_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36467,7 +36246,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36484,7 +36263,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64F_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36501,7 +36280,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq64U_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36518,7 +36297,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36535,7 +36314,7 @@
return true
}
}
-func rewriteValueAMD64_OpLeq8U_0(v *Value) bool {
+func rewriteValueAMD64_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36552,7 +36331,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16_0(v *Value) bool {
+func rewriteValueAMD64_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36569,7 +36348,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess16U_0(v *Value) bool {
+func rewriteValueAMD64_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36586,7 +36365,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32_0(v *Value) bool {
+func rewriteValueAMD64_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36603,7 +36382,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32F_0(v *Value) bool {
+func rewriteValueAMD64_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36620,7 +36399,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess32U_0(v *Value) bool {
+func rewriteValueAMD64_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36637,7 +36416,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64_0(v *Value) bool {
+func rewriteValueAMD64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36654,7 +36433,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64F_0(v *Value) bool {
+func rewriteValueAMD64_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36671,7 +36450,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess64U_0(v *Value) bool {
+func rewriteValueAMD64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36688,7 +36467,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8_0(v *Value) bool {
+func rewriteValueAMD64_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36705,7 +36484,7 @@
return true
}
}
-func rewriteValueAMD64_OpLess8U_0(v *Value) bool {
+func rewriteValueAMD64_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36722,7 +36501,7 @@
return true
}
}
-func rewriteValueAMD64_OpLoad_0(v *Value) bool {
+func rewriteValueAMD64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -36817,7 +36596,7 @@
}
return false
}
-func rewriteValueAMD64_OpLocalAddr_0(v *Value) bool {
+func rewriteValueAMD64_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (LEAQ {sym} base)
@@ -36830,7 +36609,7 @@
return true
}
}
-func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36873,7 +36652,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36916,7 +36695,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -36959,7 +36738,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37002,7 +36781,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37045,7 +36824,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37088,7 +36867,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37131,7 +36910,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37174,7 +36953,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37217,7 +36996,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37260,7 +37039,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37303,7 +37082,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37346,7 +37125,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37389,7 +37168,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37432,7 +37211,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37475,7 +37254,7 @@
}
return false
}
-func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37518,7 +37297,7 @@
}
return false
}
-func rewriteValueAMD64_OpMod16_0(v *Value) bool {
+func rewriteValueAMD64_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37538,7 +37317,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod16u_0(v *Value) bool {
+func rewriteValueAMD64_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37556,7 +37335,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32_0(v *Value) bool {
+func rewriteValueAMD64_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37576,7 +37355,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod32u_0(v *Value) bool {
+func rewriteValueAMD64_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37594,7 +37373,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64_0(v *Value) bool {
+func rewriteValueAMD64_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37614,7 +37393,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod64u_0(v *Value) bool {
+func rewriteValueAMD64_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37632,7 +37411,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8_0(v *Value) bool {
+func rewriteValueAMD64_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37654,7 +37433,7 @@
return true
}
}
-func rewriteValueAMD64_OpMod8u_0(v *Value) bool {
+func rewriteValueAMD64_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -37676,7 +37455,7 @@
return true
}
}
-func rewriteValueAMD64_OpMove_0(v *Value) bool {
+func rewriteValueAMD64_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -37909,15 +37688,6 @@
v.AddArg(v2)
return true
}
- return false
-}
-func rewriteValueAMD64_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Move [3] dst src mem)
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVWstore dst (MOVWload src mem) mem))
for {
@@ -38198,15 +37968,6 @@
v.AddArg(v2)
return true
}
- return false
-}
-func rewriteValueAMD64_OpMove_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Move [s] dst src mem)
// cond: s > 16 && s%16 != 0 && s%16 > 8 && !config.useSSE
// result: (Move [s-s%16] (OffPtr <dst.Type> dst [s%16]) (OffPtr <src.Type> src [s%16]) (MOVQstore [8] dst (MOVQload [8] src mem) (MOVQstore dst (MOVQload src mem) mem)))
@@ -38287,7 +38048,7 @@
}
return false
}
-func rewriteValueAMD64_OpNeg32F_0(v *Value) bool {
+func rewriteValueAMD64_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -38303,7 +38064,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeg64F_0(v *Value) bool {
+func rewriteValueAMD64_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -38319,7 +38080,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq16_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38336,7 +38097,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38353,7 +38114,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq32F_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38370,7 +38131,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38387,7 +38148,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq64F_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38404,7 +38165,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeq8_0(v *Value) bool {
+func rewriteValueAMD64_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38421,7 +38182,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqB_0(v *Value) bool {
+func rewriteValueAMD64_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38438,7 +38199,7 @@
return true
}
}
-func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool {
+func rewriteValueAMD64_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38455,7 +38216,7 @@
return true
}
}
-func rewriteValueAMD64_OpNot_0(v *Value) bool {
+func rewriteValueAMD64_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORLconst [1] x)
@@ -38467,7 +38228,7 @@
return true
}
}
-func rewriteValueAMD64_OpOffPtr_0(v *Value) bool {
+func rewriteValueAMD64_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -38498,7 +38259,7 @@
return true
}
}
-func rewriteValueAMD64_OpPanicBounds_0(v *Value) bool {
+func rewriteValueAMD64_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -38558,7 +38319,7 @@
}
return false
}
-func rewriteValueAMD64_OpPopCount16_0(v *Value) bool {
+func rewriteValueAMD64_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -38573,7 +38334,7 @@
return true
}
}
-func rewriteValueAMD64_OpPopCount8_0(v *Value) bool {
+func rewriteValueAMD64_OpPopCount8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -38588,7 +38349,7 @@
return true
}
}
-func rewriteValueAMD64_OpRoundToEven_0(v *Value) bool {
+func rewriteValueAMD64_OpRoundToEven(v *Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (ROUNDSD [0] x)
@@ -38600,7 +38361,7 @@
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38643,7 +38404,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38686,7 +38447,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38729,7 +38490,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38772,7 +38533,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38818,7 +38579,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38864,7 +38625,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38910,7 +38671,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38956,7 +38717,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -38999,7 +38760,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39042,7 +38803,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39085,7 +38846,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39128,7 +38889,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39174,7 +38935,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39220,7 +38981,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39266,7 +39027,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39312,7 +39073,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39355,7 +39116,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39398,7 +39159,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39441,7 +39202,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39484,7 +39245,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39530,7 +39291,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39576,7 +39337,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39622,7 +39383,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39668,7 +39429,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39711,7 +39472,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39754,7 +39515,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39797,7 +39558,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39840,7 +39601,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39886,7 +39647,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39932,7 +39693,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -39978,7 +39739,7 @@
}
return false
}
-func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -40024,7 +39785,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelect0_0(v *Value) bool {
+func rewriteValueAMD64_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -40138,7 +39899,7 @@
}
return false
}
-func rewriteValueAMD64_OpSelect1_0(v *Value) bool {
+func rewriteValueAMD64_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -40285,7 +40046,7 @@
}
return false
}
-func rewriteValueAMD64_OpSlicemask_0(v *Value) bool {
+func rewriteValueAMD64_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -40301,7 +40062,7 @@
return true
}
}
-func rewriteValueAMD64_OpStore_0(v *Value) bool {
+func rewriteValueAMD64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -40409,7 +40170,7 @@
}
return false
}
-func rewriteValueAMD64_OpTrunc_0(v *Value) bool {
+func rewriteValueAMD64_OpTrunc(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (ROUNDSD [3] x)
@@ -40421,11 +40182,12 @@
return true
}
}
-func rewriteValueAMD64_OpZero_0(v *Value) bool {
+func rewriteValueAMD64_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
+ typ := &b.Func.Config.Types
// match: (Zero [0] _ mem)
// result: mem
for {
@@ -40589,13 +40351,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueAMD64_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
// match: (Zero [16] destptr mem)
// cond: !config.useSSE
// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
@@ -40876,14 +40631,6 @@
v.AddArg(v2)
return true
}
- return false
-}
-func rewriteValueAMD64_OpZero_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Zero [s] destptr mem)
// cond: s > 64 && s <= 1024 && s%16 == 0 && !config.noDuffDevice
// result: (DUFFZERO [s] destptr (MOVOconst [0]) mem)
diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
index ec7d227..69df3f7 100644
--- a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
+++ b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go
@@ -6,25 +6,25 @@
func rewriteValueAMD64splitload(v *Value) bool {
switch v.Op {
case OpAMD64CMPBconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPBconstload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPBconstload(v)
case OpAMD64CMPBload:
- return rewriteValueAMD64splitload_OpAMD64CMPBload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPBload(v)
case OpAMD64CMPLconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPLconstload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPLconstload(v)
case OpAMD64CMPLload:
- return rewriteValueAMD64splitload_OpAMD64CMPLload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPLload(v)
case OpAMD64CMPQconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPQconstload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPQconstload(v)
case OpAMD64CMPQload:
- return rewriteValueAMD64splitload_OpAMD64CMPQload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPQload(v)
case OpAMD64CMPWconstload:
- return rewriteValueAMD64splitload_OpAMD64CMPWconstload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPWconstload(v)
case OpAMD64CMPWload:
- return rewriteValueAMD64splitload_OpAMD64CMPWload_0(v)
+ return rewriteValueAMD64splitload_OpAMD64CMPWload(v)
}
return false
}
-func rewriteValueAMD64splitload_OpAMD64CMPBconstload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPBconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -47,7 +47,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPBload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPBload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -72,7 +72,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPLconstload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPLconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -95,7 +95,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPLload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPLload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -120,7 +120,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPQconstload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPQconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -143,7 +143,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPQload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPQload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -168,7 +168,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPWconstload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPWconstload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -191,7 +191,7 @@
return true
}
}
-func rewriteValueAMD64splitload_OpAMD64CMPWload_0(v *Value) bool {
+func rewriteValueAMD64splitload_OpAMD64CMPWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go
index 76befe0..c864f1e 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM.go
@@ -9,837 +9,837 @@
func rewriteValueARM(v *Value) bool {
switch v.Op {
case OpARMADC:
- return rewriteValueARM_OpARMADC_0(v)
+ return rewriteValueARM_OpARMADC(v)
case OpARMADCconst:
- return rewriteValueARM_OpARMADCconst_0(v)
+ return rewriteValueARM_OpARMADCconst(v)
case OpARMADCshiftLL:
- return rewriteValueARM_OpARMADCshiftLL_0(v)
+ return rewriteValueARM_OpARMADCshiftLL(v)
case OpARMADCshiftLLreg:
- return rewriteValueARM_OpARMADCshiftLLreg_0(v)
+ return rewriteValueARM_OpARMADCshiftLLreg(v)
case OpARMADCshiftRA:
- return rewriteValueARM_OpARMADCshiftRA_0(v)
+ return rewriteValueARM_OpARMADCshiftRA(v)
case OpARMADCshiftRAreg:
- return rewriteValueARM_OpARMADCshiftRAreg_0(v)
+ return rewriteValueARM_OpARMADCshiftRAreg(v)
case OpARMADCshiftRL:
- return rewriteValueARM_OpARMADCshiftRL_0(v)
+ return rewriteValueARM_OpARMADCshiftRL(v)
case OpARMADCshiftRLreg:
- return rewriteValueARM_OpARMADCshiftRLreg_0(v)
+ return rewriteValueARM_OpARMADCshiftRLreg(v)
case OpARMADD:
- return rewriteValueARM_OpARMADD_0(v)
+ return rewriteValueARM_OpARMADD(v)
case OpARMADDD:
- return rewriteValueARM_OpARMADDD_0(v)
+ return rewriteValueARM_OpARMADDD(v)
case OpARMADDF:
- return rewriteValueARM_OpARMADDF_0(v)
+ return rewriteValueARM_OpARMADDF(v)
case OpARMADDS:
- return rewriteValueARM_OpARMADDS_0(v)
+ return rewriteValueARM_OpARMADDS(v)
case OpARMADDSshiftLL:
- return rewriteValueARM_OpARMADDSshiftLL_0(v)
+ return rewriteValueARM_OpARMADDSshiftLL(v)
case OpARMADDSshiftLLreg:
- return rewriteValueARM_OpARMADDSshiftLLreg_0(v)
+ return rewriteValueARM_OpARMADDSshiftLLreg(v)
case OpARMADDSshiftRA:
- return rewriteValueARM_OpARMADDSshiftRA_0(v)
+ return rewriteValueARM_OpARMADDSshiftRA(v)
case OpARMADDSshiftRAreg:
- return rewriteValueARM_OpARMADDSshiftRAreg_0(v)
+ return rewriteValueARM_OpARMADDSshiftRAreg(v)
case OpARMADDSshiftRL:
- return rewriteValueARM_OpARMADDSshiftRL_0(v)
+ return rewriteValueARM_OpARMADDSshiftRL(v)
case OpARMADDSshiftRLreg:
- return rewriteValueARM_OpARMADDSshiftRLreg_0(v)
+ return rewriteValueARM_OpARMADDSshiftRLreg(v)
case OpARMADDconst:
- return rewriteValueARM_OpARMADDconst_0(v)
+ return rewriteValueARM_OpARMADDconst(v)
case OpARMADDshiftLL:
- return rewriteValueARM_OpARMADDshiftLL_0(v)
+ return rewriteValueARM_OpARMADDshiftLL(v)
case OpARMADDshiftLLreg:
- return rewriteValueARM_OpARMADDshiftLLreg_0(v)
+ return rewriteValueARM_OpARMADDshiftLLreg(v)
case OpARMADDshiftRA:
- return rewriteValueARM_OpARMADDshiftRA_0(v)
+ return rewriteValueARM_OpARMADDshiftRA(v)
case OpARMADDshiftRAreg:
- return rewriteValueARM_OpARMADDshiftRAreg_0(v)
+ return rewriteValueARM_OpARMADDshiftRAreg(v)
case OpARMADDshiftRL:
- return rewriteValueARM_OpARMADDshiftRL_0(v)
+ return rewriteValueARM_OpARMADDshiftRL(v)
case OpARMADDshiftRLreg:
- return rewriteValueARM_OpARMADDshiftRLreg_0(v)
+ return rewriteValueARM_OpARMADDshiftRLreg(v)
case OpARMAND:
- return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v)
+ return rewriteValueARM_OpARMAND(v)
case OpARMANDconst:
- return rewriteValueARM_OpARMANDconst_0(v)
+ return rewriteValueARM_OpARMANDconst(v)
case OpARMANDshiftLL:
- return rewriteValueARM_OpARMANDshiftLL_0(v)
+ return rewriteValueARM_OpARMANDshiftLL(v)
case OpARMANDshiftLLreg:
- return rewriteValueARM_OpARMANDshiftLLreg_0(v)
+ return rewriteValueARM_OpARMANDshiftLLreg(v)
case OpARMANDshiftRA:
- return rewriteValueARM_OpARMANDshiftRA_0(v)
+ return rewriteValueARM_OpARMANDshiftRA(v)
case OpARMANDshiftRAreg:
- return rewriteValueARM_OpARMANDshiftRAreg_0(v)
+ return rewriteValueARM_OpARMANDshiftRAreg(v)
case OpARMANDshiftRL:
- return rewriteValueARM_OpARMANDshiftRL_0(v)
+ return rewriteValueARM_OpARMANDshiftRL(v)
case OpARMANDshiftRLreg:
- return rewriteValueARM_OpARMANDshiftRLreg_0(v)
+ return rewriteValueARM_OpARMANDshiftRLreg(v)
case OpARMBFX:
- return rewriteValueARM_OpARMBFX_0(v)
+ return rewriteValueARM_OpARMBFX(v)
case OpARMBFXU:
- return rewriteValueARM_OpARMBFXU_0(v)
+ return rewriteValueARM_OpARMBFXU(v)
case OpARMBIC:
- return rewriteValueARM_OpARMBIC_0(v)
+ return rewriteValueARM_OpARMBIC(v)
case OpARMBICconst:
- return rewriteValueARM_OpARMBICconst_0(v)
+ return rewriteValueARM_OpARMBICconst(v)
case OpARMBICshiftLL:
- return rewriteValueARM_OpARMBICshiftLL_0(v)
+ return rewriteValueARM_OpARMBICshiftLL(v)
case OpARMBICshiftLLreg:
- return rewriteValueARM_OpARMBICshiftLLreg_0(v)
+ return rewriteValueARM_OpARMBICshiftLLreg(v)
case OpARMBICshiftRA:
- return rewriteValueARM_OpARMBICshiftRA_0(v)
+ return rewriteValueARM_OpARMBICshiftRA(v)
case OpARMBICshiftRAreg:
- return rewriteValueARM_OpARMBICshiftRAreg_0(v)
+ return rewriteValueARM_OpARMBICshiftRAreg(v)
case OpARMBICshiftRL:
- return rewriteValueARM_OpARMBICshiftRL_0(v)
+ return rewriteValueARM_OpARMBICshiftRL(v)
case OpARMBICshiftRLreg:
- return rewriteValueARM_OpARMBICshiftRLreg_0(v)
+ return rewriteValueARM_OpARMBICshiftRLreg(v)
case OpARMCMN:
- return rewriteValueARM_OpARMCMN_0(v)
+ return rewriteValueARM_OpARMCMN(v)
case OpARMCMNconst:
- return rewriteValueARM_OpARMCMNconst_0(v)
+ return rewriteValueARM_OpARMCMNconst(v)
case OpARMCMNshiftLL:
- return rewriteValueARM_OpARMCMNshiftLL_0(v)
+ return rewriteValueARM_OpARMCMNshiftLL(v)
case OpARMCMNshiftLLreg:
- return rewriteValueARM_OpARMCMNshiftLLreg_0(v)
+ return rewriteValueARM_OpARMCMNshiftLLreg(v)
case OpARMCMNshiftRA:
- return rewriteValueARM_OpARMCMNshiftRA_0(v)
+ return rewriteValueARM_OpARMCMNshiftRA(v)
case OpARMCMNshiftRAreg:
- return rewriteValueARM_OpARMCMNshiftRAreg_0(v)
+ return rewriteValueARM_OpARMCMNshiftRAreg(v)
case OpARMCMNshiftRL:
- return rewriteValueARM_OpARMCMNshiftRL_0(v)
+ return rewriteValueARM_OpARMCMNshiftRL(v)
case OpARMCMNshiftRLreg:
- return rewriteValueARM_OpARMCMNshiftRLreg_0(v)
+ return rewriteValueARM_OpARMCMNshiftRLreg(v)
case OpARMCMOVWHSconst:
- return rewriteValueARM_OpARMCMOVWHSconst_0(v)
+ return rewriteValueARM_OpARMCMOVWHSconst(v)
case OpARMCMOVWLSconst:
- return rewriteValueARM_OpARMCMOVWLSconst_0(v)
+ return rewriteValueARM_OpARMCMOVWLSconst(v)
case OpARMCMP:
- return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v)
+ return rewriteValueARM_OpARMCMP(v)
case OpARMCMPD:
- return rewriteValueARM_OpARMCMPD_0(v)
+ return rewriteValueARM_OpARMCMPD(v)
case OpARMCMPF:
- return rewriteValueARM_OpARMCMPF_0(v)
+ return rewriteValueARM_OpARMCMPF(v)
case OpARMCMPconst:
- return rewriteValueARM_OpARMCMPconst_0(v)
+ return rewriteValueARM_OpARMCMPconst(v)
case OpARMCMPshiftLL:
- return rewriteValueARM_OpARMCMPshiftLL_0(v)
+ return rewriteValueARM_OpARMCMPshiftLL(v)
case OpARMCMPshiftLLreg:
- return rewriteValueARM_OpARMCMPshiftLLreg_0(v)
+ return rewriteValueARM_OpARMCMPshiftLLreg(v)
case OpARMCMPshiftRA:
- return rewriteValueARM_OpARMCMPshiftRA_0(v)
+ return rewriteValueARM_OpARMCMPshiftRA(v)
case OpARMCMPshiftRAreg:
- return rewriteValueARM_OpARMCMPshiftRAreg_0(v)
+ return rewriteValueARM_OpARMCMPshiftRAreg(v)
case OpARMCMPshiftRL:
- return rewriteValueARM_OpARMCMPshiftRL_0(v)
+ return rewriteValueARM_OpARMCMPshiftRL(v)
case OpARMCMPshiftRLreg:
- return rewriteValueARM_OpARMCMPshiftRLreg_0(v)
+ return rewriteValueARM_OpARMCMPshiftRLreg(v)
case OpARMEqual:
- return rewriteValueARM_OpARMEqual_0(v)
+ return rewriteValueARM_OpARMEqual(v)
case OpARMGreaterEqual:
- return rewriteValueARM_OpARMGreaterEqual_0(v)
+ return rewriteValueARM_OpARMGreaterEqual(v)
case OpARMGreaterEqualU:
- return rewriteValueARM_OpARMGreaterEqualU_0(v)
+ return rewriteValueARM_OpARMGreaterEqualU(v)
case OpARMGreaterThan:
- return rewriteValueARM_OpARMGreaterThan_0(v)
+ return rewriteValueARM_OpARMGreaterThan(v)
case OpARMGreaterThanU:
- return rewriteValueARM_OpARMGreaterThanU_0(v)
+ return rewriteValueARM_OpARMGreaterThanU(v)
case OpARMLessEqual:
- return rewriteValueARM_OpARMLessEqual_0(v)
+ return rewriteValueARM_OpARMLessEqual(v)
case OpARMLessEqualU:
- return rewriteValueARM_OpARMLessEqualU_0(v)
+ return rewriteValueARM_OpARMLessEqualU(v)
case OpARMLessThan:
- return rewriteValueARM_OpARMLessThan_0(v)
+ return rewriteValueARM_OpARMLessThan(v)
case OpARMLessThanU:
- return rewriteValueARM_OpARMLessThanU_0(v)
+ return rewriteValueARM_OpARMLessThanU(v)
case OpARMMOVBUload:
- return rewriteValueARM_OpARMMOVBUload_0(v)
+ return rewriteValueARM_OpARMMOVBUload(v)
case OpARMMOVBUloadidx:
- return rewriteValueARM_OpARMMOVBUloadidx_0(v)
+ return rewriteValueARM_OpARMMOVBUloadidx(v)
case OpARMMOVBUreg:
- return rewriteValueARM_OpARMMOVBUreg_0(v)
+ return rewriteValueARM_OpARMMOVBUreg(v)
case OpARMMOVBload:
- return rewriteValueARM_OpARMMOVBload_0(v)
+ return rewriteValueARM_OpARMMOVBload(v)
case OpARMMOVBloadidx:
- return rewriteValueARM_OpARMMOVBloadidx_0(v)
+ return rewriteValueARM_OpARMMOVBloadidx(v)
case OpARMMOVBreg:
- return rewriteValueARM_OpARMMOVBreg_0(v)
+ return rewriteValueARM_OpARMMOVBreg(v)
case OpARMMOVBstore:
- return rewriteValueARM_OpARMMOVBstore_0(v)
+ return rewriteValueARM_OpARMMOVBstore(v)
case OpARMMOVBstoreidx:
- return rewriteValueARM_OpARMMOVBstoreidx_0(v)
+ return rewriteValueARM_OpARMMOVBstoreidx(v)
case OpARMMOVDload:
- return rewriteValueARM_OpARMMOVDload_0(v)
+ return rewriteValueARM_OpARMMOVDload(v)
case OpARMMOVDstore:
- return rewriteValueARM_OpARMMOVDstore_0(v)
+ return rewriteValueARM_OpARMMOVDstore(v)
case OpARMMOVFload:
- return rewriteValueARM_OpARMMOVFload_0(v)
+ return rewriteValueARM_OpARMMOVFload(v)
case OpARMMOVFstore:
- return rewriteValueARM_OpARMMOVFstore_0(v)
+ return rewriteValueARM_OpARMMOVFstore(v)
case OpARMMOVHUload:
- return rewriteValueARM_OpARMMOVHUload_0(v)
+ return rewriteValueARM_OpARMMOVHUload(v)
case OpARMMOVHUloadidx:
- return rewriteValueARM_OpARMMOVHUloadidx_0(v)
+ return rewriteValueARM_OpARMMOVHUloadidx(v)
case OpARMMOVHUreg:
- return rewriteValueARM_OpARMMOVHUreg_0(v)
+ return rewriteValueARM_OpARMMOVHUreg(v)
case OpARMMOVHload:
- return rewriteValueARM_OpARMMOVHload_0(v)
+ return rewriteValueARM_OpARMMOVHload(v)
case OpARMMOVHloadidx:
- return rewriteValueARM_OpARMMOVHloadidx_0(v)
+ return rewriteValueARM_OpARMMOVHloadidx(v)
case OpARMMOVHreg:
- return rewriteValueARM_OpARMMOVHreg_0(v)
+ return rewriteValueARM_OpARMMOVHreg(v)
case OpARMMOVHstore:
- return rewriteValueARM_OpARMMOVHstore_0(v)
+ return rewriteValueARM_OpARMMOVHstore(v)
case OpARMMOVHstoreidx:
- return rewriteValueARM_OpARMMOVHstoreidx_0(v)
+ return rewriteValueARM_OpARMMOVHstoreidx(v)
case OpARMMOVWload:
- return rewriteValueARM_OpARMMOVWload_0(v)
+ return rewriteValueARM_OpARMMOVWload(v)
case OpARMMOVWloadidx:
- return rewriteValueARM_OpARMMOVWloadidx_0(v)
+ return rewriteValueARM_OpARMMOVWloadidx(v)
case OpARMMOVWloadshiftLL:
- return rewriteValueARM_OpARMMOVWloadshiftLL_0(v)
+ return rewriteValueARM_OpARMMOVWloadshiftLL(v)
case OpARMMOVWloadshiftRA:
- return rewriteValueARM_OpARMMOVWloadshiftRA_0(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRA(v)
case OpARMMOVWloadshiftRL:
- return rewriteValueARM_OpARMMOVWloadshiftRL_0(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRL(v)
case OpARMMOVWreg:
- return rewriteValueARM_OpARMMOVWreg_0(v)
+ return rewriteValueARM_OpARMMOVWreg(v)
case OpARMMOVWstore:
- return rewriteValueARM_OpARMMOVWstore_0(v)
+ return rewriteValueARM_OpARMMOVWstore(v)
case OpARMMOVWstoreidx:
- return rewriteValueARM_OpARMMOVWstoreidx_0(v)
+ return rewriteValueARM_OpARMMOVWstoreidx(v)
case OpARMMOVWstoreshiftLL:
- return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
case OpARMMOVWstoreshiftRA:
- return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
case OpARMMOVWstoreshiftRL:
- return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
case OpARMMUL:
- return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v)
+ return rewriteValueARM_OpARMMUL(v)
case OpARMMULA:
- return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v)
+ return rewriteValueARM_OpARMMULA(v)
case OpARMMULD:
- return rewriteValueARM_OpARMMULD_0(v)
+ return rewriteValueARM_OpARMMULD(v)
case OpARMMULF:
- return rewriteValueARM_OpARMMULF_0(v)
+ return rewriteValueARM_OpARMMULF(v)
case OpARMMULS:
- return rewriteValueARM_OpARMMULS_0(v) || rewriteValueARM_OpARMMULS_10(v) || rewriteValueARM_OpARMMULS_20(v)
+ return rewriteValueARM_OpARMMULS(v)
case OpARMMVN:
- return rewriteValueARM_OpARMMVN_0(v)
+ return rewriteValueARM_OpARMMVN(v)
case OpARMMVNshiftLL:
- return rewriteValueARM_OpARMMVNshiftLL_0(v)
+ return rewriteValueARM_OpARMMVNshiftLL(v)
case OpARMMVNshiftLLreg:
- return rewriteValueARM_OpARMMVNshiftLLreg_0(v)
+ return rewriteValueARM_OpARMMVNshiftLLreg(v)
case OpARMMVNshiftRA:
- return rewriteValueARM_OpARMMVNshiftRA_0(v)
+ return rewriteValueARM_OpARMMVNshiftRA(v)
case OpARMMVNshiftRAreg:
- return rewriteValueARM_OpARMMVNshiftRAreg_0(v)
+ return rewriteValueARM_OpARMMVNshiftRAreg(v)
case OpARMMVNshiftRL:
- return rewriteValueARM_OpARMMVNshiftRL_0(v)
+ return rewriteValueARM_OpARMMVNshiftRL(v)
case OpARMMVNshiftRLreg:
- return rewriteValueARM_OpARMMVNshiftRLreg_0(v)
+ return rewriteValueARM_OpARMMVNshiftRLreg(v)
case OpARMNEGD:
- return rewriteValueARM_OpARMNEGD_0(v)
+ return rewriteValueARM_OpARMNEGD(v)
case OpARMNEGF:
- return rewriteValueARM_OpARMNEGF_0(v)
+ return rewriteValueARM_OpARMNEGF(v)
case OpARMNMULD:
- return rewriteValueARM_OpARMNMULD_0(v)
+ return rewriteValueARM_OpARMNMULD(v)
case OpARMNMULF:
- return rewriteValueARM_OpARMNMULF_0(v)
+ return rewriteValueARM_OpARMNMULF(v)
case OpARMNotEqual:
- return rewriteValueARM_OpARMNotEqual_0(v)
+ return rewriteValueARM_OpARMNotEqual(v)
case OpARMOR:
- return rewriteValueARM_OpARMOR_0(v)
+ return rewriteValueARM_OpARMOR(v)
case OpARMORconst:
- return rewriteValueARM_OpARMORconst_0(v)
+ return rewriteValueARM_OpARMORconst(v)
case OpARMORshiftLL:
- return rewriteValueARM_OpARMORshiftLL_0(v)
+ return rewriteValueARM_OpARMORshiftLL(v)
case OpARMORshiftLLreg:
- return rewriteValueARM_OpARMORshiftLLreg_0(v)
+ return rewriteValueARM_OpARMORshiftLLreg(v)
case OpARMORshiftRA:
- return rewriteValueARM_OpARMORshiftRA_0(v)
+ return rewriteValueARM_OpARMORshiftRA(v)
case OpARMORshiftRAreg:
- return rewriteValueARM_OpARMORshiftRAreg_0(v)
+ return rewriteValueARM_OpARMORshiftRAreg(v)
case OpARMORshiftRL:
- return rewriteValueARM_OpARMORshiftRL_0(v)
+ return rewriteValueARM_OpARMORshiftRL(v)
case OpARMORshiftRLreg:
- return rewriteValueARM_OpARMORshiftRLreg_0(v)
+ return rewriteValueARM_OpARMORshiftRLreg(v)
case OpARMRSB:
- return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v)
+ return rewriteValueARM_OpARMRSB(v)
case OpARMRSBSshiftLL:
- return rewriteValueARM_OpARMRSBSshiftLL_0(v)
+ return rewriteValueARM_OpARMRSBSshiftLL(v)
case OpARMRSBSshiftLLreg:
- return rewriteValueARM_OpARMRSBSshiftLLreg_0(v)
+ return rewriteValueARM_OpARMRSBSshiftLLreg(v)
case OpARMRSBSshiftRA:
- return rewriteValueARM_OpARMRSBSshiftRA_0(v)
+ return rewriteValueARM_OpARMRSBSshiftRA(v)
case OpARMRSBSshiftRAreg:
- return rewriteValueARM_OpARMRSBSshiftRAreg_0(v)
+ return rewriteValueARM_OpARMRSBSshiftRAreg(v)
case OpARMRSBSshiftRL:
- return rewriteValueARM_OpARMRSBSshiftRL_0(v)
+ return rewriteValueARM_OpARMRSBSshiftRL(v)
case OpARMRSBSshiftRLreg:
- return rewriteValueARM_OpARMRSBSshiftRLreg_0(v)
+ return rewriteValueARM_OpARMRSBSshiftRLreg(v)
case OpARMRSBconst:
- return rewriteValueARM_OpARMRSBconst_0(v)
+ return rewriteValueARM_OpARMRSBconst(v)
case OpARMRSBshiftLL:
- return rewriteValueARM_OpARMRSBshiftLL_0(v)
+ return rewriteValueARM_OpARMRSBshiftLL(v)
case OpARMRSBshiftLLreg:
- return rewriteValueARM_OpARMRSBshiftLLreg_0(v)
+ return rewriteValueARM_OpARMRSBshiftLLreg(v)
case OpARMRSBshiftRA:
- return rewriteValueARM_OpARMRSBshiftRA_0(v)
+ return rewriteValueARM_OpARMRSBshiftRA(v)
case OpARMRSBshiftRAreg:
- return rewriteValueARM_OpARMRSBshiftRAreg_0(v)
+ return rewriteValueARM_OpARMRSBshiftRAreg(v)
case OpARMRSBshiftRL:
- return rewriteValueARM_OpARMRSBshiftRL_0(v)
+ return rewriteValueARM_OpARMRSBshiftRL(v)
case OpARMRSBshiftRLreg:
- return rewriteValueARM_OpARMRSBshiftRLreg_0(v)
+ return rewriteValueARM_OpARMRSBshiftRLreg(v)
case OpARMRSCconst:
- return rewriteValueARM_OpARMRSCconst_0(v)
+ return rewriteValueARM_OpARMRSCconst(v)
case OpARMRSCshiftLL:
- return rewriteValueARM_OpARMRSCshiftLL_0(v)
+ return rewriteValueARM_OpARMRSCshiftLL(v)
case OpARMRSCshiftLLreg:
- return rewriteValueARM_OpARMRSCshiftLLreg_0(v)
+ return rewriteValueARM_OpARMRSCshiftLLreg(v)
case OpARMRSCshiftRA:
- return rewriteValueARM_OpARMRSCshiftRA_0(v)
+ return rewriteValueARM_OpARMRSCshiftRA(v)
case OpARMRSCshiftRAreg:
- return rewriteValueARM_OpARMRSCshiftRAreg_0(v)
+ return rewriteValueARM_OpARMRSCshiftRAreg(v)
case OpARMRSCshiftRL:
- return rewriteValueARM_OpARMRSCshiftRL_0(v)
+ return rewriteValueARM_OpARMRSCshiftRL(v)
case OpARMRSCshiftRLreg:
- return rewriteValueARM_OpARMRSCshiftRLreg_0(v)
+ return rewriteValueARM_OpARMRSCshiftRLreg(v)
case OpARMSBC:
- return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v)
+ return rewriteValueARM_OpARMSBC(v)
case OpARMSBCconst:
- return rewriteValueARM_OpARMSBCconst_0(v)
+ return rewriteValueARM_OpARMSBCconst(v)
case OpARMSBCshiftLL:
- return rewriteValueARM_OpARMSBCshiftLL_0(v)
+ return rewriteValueARM_OpARMSBCshiftLL(v)
case OpARMSBCshiftLLreg:
- return rewriteValueARM_OpARMSBCshiftLLreg_0(v)
+ return rewriteValueARM_OpARMSBCshiftLLreg(v)
case OpARMSBCshiftRA:
- return rewriteValueARM_OpARMSBCshiftRA_0(v)
+ return rewriteValueARM_OpARMSBCshiftRA(v)
case OpARMSBCshiftRAreg:
- return rewriteValueARM_OpARMSBCshiftRAreg_0(v)
+ return rewriteValueARM_OpARMSBCshiftRAreg(v)
case OpARMSBCshiftRL:
- return rewriteValueARM_OpARMSBCshiftRL_0(v)
+ return rewriteValueARM_OpARMSBCshiftRL(v)
case OpARMSBCshiftRLreg:
- return rewriteValueARM_OpARMSBCshiftRLreg_0(v)
+ return rewriteValueARM_OpARMSBCshiftRLreg(v)
case OpARMSLL:
- return rewriteValueARM_OpARMSLL_0(v)
+ return rewriteValueARM_OpARMSLL(v)
case OpARMSLLconst:
- return rewriteValueARM_OpARMSLLconst_0(v)
+ return rewriteValueARM_OpARMSLLconst(v)
case OpARMSRA:
- return rewriteValueARM_OpARMSRA_0(v)
+ return rewriteValueARM_OpARMSRA(v)
case OpARMSRAcond:
- return rewriteValueARM_OpARMSRAcond_0(v)
+ return rewriteValueARM_OpARMSRAcond(v)
case OpARMSRAconst:
- return rewriteValueARM_OpARMSRAconst_0(v)
+ return rewriteValueARM_OpARMSRAconst(v)
case OpARMSRL:
- return rewriteValueARM_OpARMSRL_0(v)
+ return rewriteValueARM_OpARMSRL(v)
case OpARMSRLconst:
- return rewriteValueARM_OpARMSRLconst_0(v)
+ return rewriteValueARM_OpARMSRLconst(v)
case OpARMSUB:
- return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v)
+ return rewriteValueARM_OpARMSUB(v)
case OpARMSUBD:
- return rewriteValueARM_OpARMSUBD_0(v)
+ return rewriteValueARM_OpARMSUBD(v)
case OpARMSUBF:
- return rewriteValueARM_OpARMSUBF_0(v)
+ return rewriteValueARM_OpARMSUBF(v)
case OpARMSUBS:
- return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v)
+ return rewriteValueARM_OpARMSUBS(v)
case OpARMSUBSshiftLL:
- return rewriteValueARM_OpARMSUBSshiftLL_0(v)
+ return rewriteValueARM_OpARMSUBSshiftLL(v)
case OpARMSUBSshiftLLreg:
- return rewriteValueARM_OpARMSUBSshiftLLreg_0(v)
+ return rewriteValueARM_OpARMSUBSshiftLLreg(v)
case OpARMSUBSshiftRA:
- return rewriteValueARM_OpARMSUBSshiftRA_0(v)
+ return rewriteValueARM_OpARMSUBSshiftRA(v)
case OpARMSUBSshiftRAreg:
- return rewriteValueARM_OpARMSUBSshiftRAreg_0(v)
+ return rewriteValueARM_OpARMSUBSshiftRAreg(v)
case OpARMSUBSshiftRL:
- return rewriteValueARM_OpARMSUBSshiftRL_0(v)
+ return rewriteValueARM_OpARMSUBSshiftRL(v)
case OpARMSUBSshiftRLreg:
- return rewriteValueARM_OpARMSUBSshiftRLreg_0(v)
+ return rewriteValueARM_OpARMSUBSshiftRLreg(v)
case OpARMSUBconst:
- return rewriteValueARM_OpARMSUBconst_0(v)
+ return rewriteValueARM_OpARMSUBconst(v)
case OpARMSUBshiftLL:
- return rewriteValueARM_OpARMSUBshiftLL_0(v)
+ return rewriteValueARM_OpARMSUBshiftLL(v)
case OpARMSUBshiftLLreg:
- return rewriteValueARM_OpARMSUBshiftLLreg_0(v)
+ return rewriteValueARM_OpARMSUBshiftLLreg(v)
case OpARMSUBshiftRA:
- return rewriteValueARM_OpARMSUBshiftRA_0(v)
+ return rewriteValueARM_OpARMSUBshiftRA(v)
case OpARMSUBshiftRAreg:
- return rewriteValueARM_OpARMSUBshiftRAreg_0(v)
+ return rewriteValueARM_OpARMSUBshiftRAreg(v)
case OpARMSUBshiftRL:
- return rewriteValueARM_OpARMSUBshiftRL_0(v)
+ return rewriteValueARM_OpARMSUBshiftRL(v)
case OpARMSUBshiftRLreg:
- return rewriteValueARM_OpARMSUBshiftRLreg_0(v)
+ return rewriteValueARM_OpARMSUBshiftRLreg(v)
case OpARMTEQ:
- return rewriteValueARM_OpARMTEQ_0(v)
+ return rewriteValueARM_OpARMTEQ(v)
case OpARMTEQconst:
- return rewriteValueARM_OpARMTEQconst_0(v)
+ return rewriteValueARM_OpARMTEQconst(v)
case OpARMTEQshiftLL:
- return rewriteValueARM_OpARMTEQshiftLL_0(v)
+ return rewriteValueARM_OpARMTEQshiftLL(v)
case OpARMTEQshiftLLreg:
- return rewriteValueARM_OpARMTEQshiftLLreg_0(v)
+ return rewriteValueARM_OpARMTEQshiftLLreg(v)
case OpARMTEQshiftRA:
- return rewriteValueARM_OpARMTEQshiftRA_0(v)
+ return rewriteValueARM_OpARMTEQshiftRA(v)
case OpARMTEQshiftRAreg:
- return rewriteValueARM_OpARMTEQshiftRAreg_0(v)
+ return rewriteValueARM_OpARMTEQshiftRAreg(v)
case OpARMTEQshiftRL:
- return rewriteValueARM_OpARMTEQshiftRL_0(v)
+ return rewriteValueARM_OpARMTEQshiftRL(v)
case OpARMTEQshiftRLreg:
- return rewriteValueARM_OpARMTEQshiftRLreg_0(v)
+ return rewriteValueARM_OpARMTEQshiftRLreg(v)
case OpARMTST:
- return rewriteValueARM_OpARMTST_0(v)
+ return rewriteValueARM_OpARMTST(v)
case OpARMTSTconst:
- return rewriteValueARM_OpARMTSTconst_0(v)
+ return rewriteValueARM_OpARMTSTconst(v)
case OpARMTSTshiftLL:
- return rewriteValueARM_OpARMTSTshiftLL_0(v)
+ return rewriteValueARM_OpARMTSTshiftLL(v)
case OpARMTSTshiftLLreg:
- return rewriteValueARM_OpARMTSTshiftLLreg_0(v)
+ return rewriteValueARM_OpARMTSTshiftLLreg(v)
case OpARMTSTshiftRA:
- return rewriteValueARM_OpARMTSTshiftRA_0(v)
+ return rewriteValueARM_OpARMTSTshiftRA(v)
case OpARMTSTshiftRAreg:
- return rewriteValueARM_OpARMTSTshiftRAreg_0(v)
+ return rewriteValueARM_OpARMTSTshiftRAreg(v)
case OpARMTSTshiftRL:
- return rewriteValueARM_OpARMTSTshiftRL_0(v)
+ return rewriteValueARM_OpARMTSTshiftRL(v)
case OpARMTSTshiftRLreg:
- return rewriteValueARM_OpARMTSTshiftRLreg_0(v)
+ return rewriteValueARM_OpARMTSTshiftRLreg(v)
case OpARMXOR:
- return rewriteValueARM_OpARMXOR_0(v)
+ return rewriteValueARM_OpARMXOR(v)
case OpARMXORconst:
- return rewriteValueARM_OpARMXORconst_0(v)
+ return rewriteValueARM_OpARMXORconst(v)
case OpARMXORshiftLL:
- return rewriteValueARM_OpARMXORshiftLL_0(v)
+ return rewriteValueARM_OpARMXORshiftLL(v)
case OpARMXORshiftLLreg:
- return rewriteValueARM_OpARMXORshiftLLreg_0(v)
+ return rewriteValueARM_OpARMXORshiftLLreg(v)
case OpARMXORshiftRA:
- return rewriteValueARM_OpARMXORshiftRA_0(v)
+ return rewriteValueARM_OpARMXORshiftRA(v)
case OpARMXORshiftRAreg:
- return rewriteValueARM_OpARMXORshiftRAreg_0(v)
+ return rewriteValueARM_OpARMXORshiftRAreg(v)
case OpARMXORshiftRL:
- return rewriteValueARM_OpARMXORshiftRL_0(v)
+ return rewriteValueARM_OpARMXORshiftRL(v)
case OpARMXORshiftRLreg:
- return rewriteValueARM_OpARMXORshiftRLreg_0(v)
+ return rewriteValueARM_OpARMXORshiftRLreg(v)
case OpARMXORshiftRR:
- return rewriteValueARM_OpARMXORshiftRR_0(v)
+ return rewriteValueARM_OpARMXORshiftRR(v)
case OpAbs:
- return rewriteValueARM_OpAbs_0(v)
+ return rewriteValueARM_OpAbs(v)
case OpAdd16:
- return rewriteValueARM_OpAdd16_0(v)
+ return rewriteValueARM_OpAdd16(v)
case OpAdd32:
- return rewriteValueARM_OpAdd32_0(v)
+ return rewriteValueARM_OpAdd32(v)
case OpAdd32F:
- return rewriteValueARM_OpAdd32F_0(v)
+ return rewriteValueARM_OpAdd32F(v)
case OpAdd32carry:
- return rewriteValueARM_OpAdd32carry_0(v)
+ return rewriteValueARM_OpAdd32carry(v)
case OpAdd32withcarry:
- return rewriteValueARM_OpAdd32withcarry_0(v)
+ return rewriteValueARM_OpAdd32withcarry(v)
case OpAdd64F:
- return rewriteValueARM_OpAdd64F_0(v)
+ return rewriteValueARM_OpAdd64F(v)
case OpAdd8:
- return rewriteValueARM_OpAdd8_0(v)
+ return rewriteValueARM_OpAdd8(v)
case OpAddPtr:
- return rewriteValueARM_OpAddPtr_0(v)
+ return rewriteValueARM_OpAddPtr(v)
case OpAddr:
- return rewriteValueARM_OpAddr_0(v)
+ return rewriteValueARM_OpAddr(v)
case OpAnd16:
- return rewriteValueARM_OpAnd16_0(v)
+ return rewriteValueARM_OpAnd16(v)
case OpAnd32:
- return rewriteValueARM_OpAnd32_0(v)
+ return rewriteValueARM_OpAnd32(v)
case OpAnd8:
- return rewriteValueARM_OpAnd8_0(v)
+ return rewriteValueARM_OpAnd8(v)
case OpAndB:
- return rewriteValueARM_OpAndB_0(v)
+ return rewriteValueARM_OpAndB(v)
case OpAvg32u:
- return rewriteValueARM_OpAvg32u_0(v)
+ return rewriteValueARM_OpAvg32u(v)
case OpBitLen32:
- return rewriteValueARM_OpBitLen32_0(v)
+ return rewriteValueARM_OpBitLen32(v)
case OpBswap32:
- return rewriteValueARM_OpBswap32_0(v)
+ return rewriteValueARM_OpBswap32(v)
case OpClosureCall:
- return rewriteValueARM_OpClosureCall_0(v)
+ return rewriteValueARM_OpClosureCall(v)
case OpCom16:
- return rewriteValueARM_OpCom16_0(v)
+ return rewriteValueARM_OpCom16(v)
case OpCom32:
- return rewriteValueARM_OpCom32_0(v)
+ return rewriteValueARM_OpCom32(v)
case OpCom8:
- return rewriteValueARM_OpCom8_0(v)
+ return rewriteValueARM_OpCom8(v)
case OpConst16:
- return rewriteValueARM_OpConst16_0(v)
+ return rewriteValueARM_OpConst16(v)
case OpConst32:
- return rewriteValueARM_OpConst32_0(v)
+ return rewriteValueARM_OpConst32(v)
case OpConst32F:
- return rewriteValueARM_OpConst32F_0(v)
+ return rewriteValueARM_OpConst32F(v)
case OpConst64F:
- return rewriteValueARM_OpConst64F_0(v)
+ return rewriteValueARM_OpConst64F(v)
case OpConst8:
- return rewriteValueARM_OpConst8_0(v)
+ return rewriteValueARM_OpConst8(v)
case OpConstBool:
- return rewriteValueARM_OpConstBool_0(v)
+ return rewriteValueARM_OpConstBool(v)
case OpConstNil:
- return rewriteValueARM_OpConstNil_0(v)
+ return rewriteValueARM_OpConstNil(v)
case OpCtz16:
- return rewriteValueARM_OpCtz16_0(v)
+ return rewriteValueARM_OpCtz16(v)
case OpCtz16NonZero:
- return rewriteValueARM_OpCtz16NonZero_0(v)
+ return rewriteValueARM_OpCtz16NonZero(v)
case OpCtz32:
- return rewriteValueARM_OpCtz32_0(v)
+ return rewriteValueARM_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueARM_OpCtz32NonZero_0(v)
+ return rewriteValueARM_OpCtz32NonZero(v)
case OpCtz8:
- return rewriteValueARM_OpCtz8_0(v)
+ return rewriteValueARM_OpCtz8(v)
case OpCtz8NonZero:
- return rewriteValueARM_OpCtz8NonZero_0(v)
+ return rewriteValueARM_OpCtz8NonZero(v)
case OpCvt32Fto32:
- return rewriteValueARM_OpCvt32Fto32_0(v)
+ return rewriteValueARM_OpCvt32Fto32(v)
case OpCvt32Fto32U:
- return rewriteValueARM_OpCvt32Fto32U_0(v)
+ return rewriteValueARM_OpCvt32Fto32U(v)
case OpCvt32Fto64F:
- return rewriteValueARM_OpCvt32Fto64F_0(v)
+ return rewriteValueARM_OpCvt32Fto64F(v)
case OpCvt32Uto32F:
- return rewriteValueARM_OpCvt32Uto32F_0(v)
+ return rewriteValueARM_OpCvt32Uto32F(v)
case OpCvt32Uto64F:
- return rewriteValueARM_OpCvt32Uto64F_0(v)
+ return rewriteValueARM_OpCvt32Uto64F(v)
case OpCvt32to32F:
- return rewriteValueARM_OpCvt32to32F_0(v)
+ return rewriteValueARM_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueARM_OpCvt32to64F_0(v)
+ return rewriteValueARM_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueARM_OpCvt64Fto32_0(v)
+ return rewriteValueARM_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueARM_OpCvt64Fto32F_0(v)
+ return rewriteValueARM_OpCvt64Fto32F(v)
case OpCvt64Fto32U:
- return rewriteValueARM_OpCvt64Fto32U_0(v)
+ return rewriteValueARM_OpCvt64Fto32U(v)
case OpDiv16:
- return rewriteValueARM_OpDiv16_0(v)
+ return rewriteValueARM_OpDiv16(v)
case OpDiv16u:
- return rewriteValueARM_OpDiv16u_0(v)
+ return rewriteValueARM_OpDiv16u(v)
case OpDiv32:
- return rewriteValueARM_OpDiv32_0(v)
+ return rewriteValueARM_OpDiv32(v)
case OpDiv32F:
- return rewriteValueARM_OpDiv32F_0(v)
+ return rewriteValueARM_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueARM_OpDiv32u_0(v)
+ return rewriteValueARM_OpDiv32u(v)
case OpDiv64F:
- return rewriteValueARM_OpDiv64F_0(v)
+ return rewriteValueARM_OpDiv64F(v)
case OpDiv8:
- return rewriteValueARM_OpDiv8_0(v)
+ return rewriteValueARM_OpDiv8(v)
case OpDiv8u:
- return rewriteValueARM_OpDiv8u_0(v)
+ return rewriteValueARM_OpDiv8u(v)
case OpEq16:
- return rewriteValueARM_OpEq16_0(v)
+ return rewriteValueARM_OpEq16(v)
case OpEq32:
- return rewriteValueARM_OpEq32_0(v)
+ return rewriteValueARM_OpEq32(v)
case OpEq32F:
- return rewriteValueARM_OpEq32F_0(v)
+ return rewriteValueARM_OpEq32F(v)
case OpEq64F:
- return rewriteValueARM_OpEq64F_0(v)
+ return rewriteValueARM_OpEq64F(v)
case OpEq8:
- return rewriteValueARM_OpEq8_0(v)
+ return rewriteValueARM_OpEq8(v)
case OpEqB:
- return rewriteValueARM_OpEqB_0(v)
+ return rewriteValueARM_OpEqB(v)
case OpEqPtr:
- return rewriteValueARM_OpEqPtr_0(v)
+ return rewriteValueARM_OpEqPtr(v)
case OpFMA:
- return rewriteValueARM_OpFMA_0(v)
+ return rewriteValueARM_OpFMA(v)
case OpGeq16:
- return rewriteValueARM_OpGeq16_0(v)
+ return rewriteValueARM_OpGeq16(v)
case OpGeq16U:
- return rewriteValueARM_OpGeq16U_0(v)
+ return rewriteValueARM_OpGeq16U(v)
case OpGeq32:
- return rewriteValueARM_OpGeq32_0(v)
+ return rewriteValueARM_OpGeq32(v)
case OpGeq32F:
- return rewriteValueARM_OpGeq32F_0(v)
+ return rewriteValueARM_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueARM_OpGeq32U_0(v)
+ return rewriteValueARM_OpGeq32U(v)
case OpGeq64F:
- return rewriteValueARM_OpGeq64F_0(v)
+ return rewriteValueARM_OpGeq64F(v)
case OpGeq8:
- return rewriteValueARM_OpGeq8_0(v)
+ return rewriteValueARM_OpGeq8(v)
case OpGeq8U:
- return rewriteValueARM_OpGeq8U_0(v)
+ return rewriteValueARM_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueARM_OpGetCallerPC_0(v)
+ return rewriteValueARM_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueARM_OpGetCallerSP_0(v)
+ return rewriteValueARM_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueARM_OpGetClosurePtr_0(v)
+ return rewriteValueARM_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueARM_OpGreater16_0(v)
+ return rewriteValueARM_OpGreater16(v)
case OpGreater16U:
- return rewriteValueARM_OpGreater16U_0(v)
+ return rewriteValueARM_OpGreater16U(v)
case OpGreater32:
- return rewriteValueARM_OpGreater32_0(v)
+ return rewriteValueARM_OpGreater32(v)
case OpGreater32F:
- return rewriteValueARM_OpGreater32F_0(v)
+ return rewriteValueARM_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueARM_OpGreater32U_0(v)
+ return rewriteValueARM_OpGreater32U(v)
case OpGreater64F:
- return rewriteValueARM_OpGreater64F_0(v)
+ return rewriteValueARM_OpGreater64F(v)
case OpGreater8:
- return rewriteValueARM_OpGreater8_0(v)
+ return rewriteValueARM_OpGreater8(v)
case OpGreater8U:
- return rewriteValueARM_OpGreater8U_0(v)
+ return rewriteValueARM_OpGreater8U(v)
case OpHmul32:
- return rewriteValueARM_OpHmul32_0(v)
+ return rewriteValueARM_OpHmul32(v)
case OpHmul32u:
- return rewriteValueARM_OpHmul32u_0(v)
+ return rewriteValueARM_OpHmul32u(v)
case OpInterCall:
- return rewriteValueARM_OpInterCall_0(v)
+ return rewriteValueARM_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueARM_OpIsInBounds_0(v)
+ return rewriteValueARM_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueARM_OpIsNonNil_0(v)
+ return rewriteValueARM_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueARM_OpIsSliceInBounds_0(v)
+ return rewriteValueARM_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueARM_OpLeq16_0(v)
+ return rewriteValueARM_OpLeq16(v)
case OpLeq16U:
- return rewriteValueARM_OpLeq16U_0(v)
+ return rewriteValueARM_OpLeq16U(v)
case OpLeq32:
- return rewriteValueARM_OpLeq32_0(v)
+ return rewriteValueARM_OpLeq32(v)
case OpLeq32F:
- return rewriteValueARM_OpLeq32F_0(v)
+ return rewriteValueARM_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueARM_OpLeq32U_0(v)
+ return rewriteValueARM_OpLeq32U(v)
case OpLeq64F:
- return rewriteValueARM_OpLeq64F_0(v)
+ return rewriteValueARM_OpLeq64F(v)
case OpLeq8:
- return rewriteValueARM_OpLeq8_0(v)
+ return rewriteValueARM_OpLeq8(v)
case OpLeq8U:
- return rewriteValueARM_OpLeq8U_0(v)
+ return rewriteValueARM_OpLeq8U(v)
case OpLess16:
- return rewriteValueARM_OpLess16_0(v)
+ return rewriteValueARM_OpLess16(v)
case OpLess16U:
- return rewriteValueARM_OpLess16U_0(v)
+ return rewriteValueARM_OpLess16U(v)
case OpLess32:
- return rewriteValueARM_OpLess32_0(v)
+ return rewriteValueARM_OpLess32(v)
case OpLess32F:
- return rewriteValueARM_OpLess32F_0(v)
+ return rewriteValueARM_OpLess32F(v)
case OpLess32U:
- return rewriteValueARM_OpLess32U_0(v)
+ return rewriteValueARM_OpLess32U(v)
case OpLess64F:
- return rewriteValueARM_OpLess64F_0(v)
+ return rewriteValueARM_OpLess64F(v)
case OpLess8:
- return rewriteValueARM_OpLess8_0(v)
+ return rewriteValueARM_OpLess8(v)
case OpLess8U:
- return rewriteValueARM_OpLess8U_0(v)
+ return rewriteValueARM_OpLess8U(v)
case OpLoad:
- return rewriteValueARM_OpLoad_0(v)
+ return rewriteValueARM_OpLoad(v)
case OpLocalAddr:
- return rewriteValueARM_OpLocalAddr_0(v)
+ return rewriteValueARM_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueARM_OpLsh16x16_0(v)
+ return rewriteValueARM_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueARM_OpLsh16x32_0(v)
+ return rewriteValueARM_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueARM_OpLsh16x64_0(v)
+ return rewriteValueARM_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueARM_OpLsh16x8_0(v)
+ return rewriteValueARM_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueARM_OpLsh32x16_0(v)
+ return rewriteValueARM_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueARM_OpLsh32x32_0(v)
+ return rewriteValueARM_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueARM_OpLsh32x64_0(v)
+ return rewriteValueARM_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueARM_OpLsh32x8_0(v)
+ return rewriteValueARM_OpLsh32x8(v)
case OpLsh8x16:
- return rewriteValueARM_OpLsh8x16_0(v)
+ return rewriteValueARM_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueARM_OpLsh8x32_0(v)
+ return rewriteValueARM_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueARM_OpLsh8x64_0(v)
+ return rewriteValueARM_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueARM_OpLsh8x8_0(v)
+ return rewriteValueARM_OpLsh8x8(v)
case OpMod16:
- return rewriteValueARM_OpMod16_0(v)
+ return rewriteValueARM_OpMod16(v)
case OpMod16u:
- return rewriteValueARM_OpMod16u_0(v)
+ return rewriteValueARM_OpMod16u(v)
case OpMod32:
- return rewriteValueARM_OpMod32_0(v)
+ return rewriteValueARM_OpMod32(v)
case OpMod32u:
- return rewriteValueARM_OpMod32u_0(v)
+ return rewriteValueARM_OpMod32u(v)
case OpMod8:
- return rewriteValueARM_OpMod8_0(v)
+ return rewriteValueARM_OpMod8(v)
case OpMod8u:
- return rewriteValueARM_OpMod8u_0(v)
+ return rewriteValueARM_OpMod8u(v)
case OpMove:
- return rewriteValueARM_OpMove_0(v)
+ return rewriteValueARM_OpMove(v)
case OpMul16:
- return rewriteValueARM_OpMul16_0(v)
+ return rewriteValueARM_OpMul16(v)
case OpMul32:
- return rewriteValueARM_OpMul32_0(v)
+ return rewriteValueARM_OpMul32(v)
case OpMul32F:
- return rewriteValueARM_OpMul32F_0(v)
+ return rewriteValueARM_OpMul32F(v)
case OpMul32uhilo:
- return rewriteValueARM_OpMul32uhilo_0(v)
+ return rewriteValueARM_OpMul32uhilo(v)
case OpMul64F:
- return rewriteValueARM_OpMul64F_0(v)
+ return rewriteValueARM_OpMul64F(v)
case OpMul8:
- return rewriteValueARM_OpMul8_0(v)
+ return rewriteValueARM_OpMul8(v)
case OpNeg16:
- return rewriteValueARM_OpNeg16_0(v)
+ return rewriteValueARM_OpNeg16(v)
case OpNeg32:
- return rewriteValueARM_OpNeg32_0(v)
+ return rewriteValueARM_OpNeg32(v)
case OpNeg32F:
- return rewriteValueARM_OpNeg32F_0(v)
+ return rewriteValueARM_OpNeg32F(v)
case OpNeg64F:
- return rewriteValueARM_OpNeg64F_0(v)
+ return rewriteValueARM_OpNeg64F(v)
case OpNeg8:
- return rewriteValueARM_OpNeg8_0(v)
+ return rewriteValueARM_OpNeg8(v)
case OpNeq16:
- return rewriteValueARM_OpNeq16_0(v)
+ return rewriteValueARM_OpNeq16(v)
case OpNeq32:
- return rewriteValueARM_OpNeq32_0(v)
+ return rewriteValueARM_OpNeq32(v)
case OpNeq32F:
- return rewriteValueARM_OpNeq32F_0(v)
+ return rewriteValueARM_OpNeq32F(v)
case OpNeq64F:
- return rewriteValueARM_OpNeq64F_0(v)
+ return rewriteValueARM_OpNeq64F(v)
case OpNeq8:
- return rewriteValueARM_OpNeq8_0(v)
+ return rewriteValueARM_OpNeq8(v)
case OpNeqB:
- return rewriteValueARM_OpNeqB_0(v)
+ return rewriteValueARM_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueARM_OpNeqPtr_0(v)
+ return rewriteValueARM_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueARM_OpNilCheck_0(v)
+ return rewriteValueARM_OpNilCheck(v)
case OpNot:
- return rewriteValueARM_OpNot_0(v)
+ return rewriteValueARM_OpNot(v)
case OpOffPtr:
- return rewriteValueARM_OpOffPtr_0(v)
+ return rewriteValueARM_OpOffPtr(v)
case OpOr16:
- return rewriteValueARM_OpOr16_0(v)
+ return rewriteValueARM_OpOr16(v)
case OpOr32:
- return rewriteValueARM_OpOr32_0(v)
+ return rewriteValueARM_OpOr32(v)
case OpOr8:
- return rewriteValueARM_OpOr8_0(v)
+ return rewriteValueARM_OpOr8(v)
case OpOrB:
- return rewriteValueARM_OpOrB_0(v)
+ return rewriteValueARM_OpOrB(v)
case OpPanicBounds:
- return rewriteValueARM_OpPanicBounds_0(v)
+ return rewriteValueARM_OpPanicBounds(v)
case OpPanicExtend:
- return rewriteValueARM_OpPanicExtend_0(v)
+ return rewriteValueARM_OpPanicExtend(v)
case OpRotateLeft16:
- return rewriteValueARM_OpRotateLeft16_0(v)
+ return rewriteValueARM_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueARM_OpRotateLeft32_0(v)
+ return rewriteValueARM_OpRotateLeft32(v)
case OpRotateLeft8:
- return rewriteValueARM_OpRotateLeft8_0(v)
+ return rewriteValueARM_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueARM_OpRound32F_0(v)
+ return rewriteValueARM_OpRound32F(v)
case OpRound64F:
- return rewriteValueARM_OpRound64F_0(v)
+ return rewriteValueARM_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValueARM_OpRsh16Ux16_0(v)
+ return rewriteValueARM_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueARM_OpRsh16Ux32_0(v)
+ return rewriteValueARM_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueARM_OpRsh16Ux64_0(v)
+ return rewriteValueARM_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueARM_OpRsh16Ux8_0(v)
+ return rewriteValueARM_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueARM_OpRsh16x16_0(v)
+ return rewriteValueARM_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueARM_OpRsh16x32_0(v)
+ return rewriteValueARM_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueARM_OpRsh16x64_0(v)
+ return rewriteValueARM_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueARM_OpRsh16x8_0(v)
+ return rewriteValueARM_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueARM_OpRsh32Ux16_0(v)
+ return rewriteValueARM_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueARM_OpRsh32Ux32_0(v)
+ return rewriteValueARM_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueARM_OpRsh32Ux64_0(v)
+ return rewriteValueARM_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueARM_OpRsh32Ux8_0(v)
+ return rewriteValueARM_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueARM_OpRsh32x16_0(v)
+ return rewriteValueARM_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueARM_OpRsh32x32_0(v)
+ return rewriteValueARM_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueARM_OpRsh32x64_0(v)
+ return rewriteValueARM_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueARM_OpRsh32x8_0(v)
+ return rewriteValueARM_OpRsh32x8(v)
case OpRsh8Ux16:
- return rewriteValueARM_OpRsh8Ux16_0(v)
+ return rewriteValueARM_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueARM_OpRsh8Ux32_0(v)
+ return rewriteValueARM_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueARM_OpRsh8Ux64_0(v)
+ return rewriteValueARM_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueARM_OpRsh8Ux8_0(v)
+ return rewriteValueARM_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueARM_OpRsh8x16_0(v)
+ return rewriteValueARM_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueARM_OpRsh8x32_0(v)
+ return rewriteValueARM_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueARM_OpRsh8x64_0(v)
+ return rewriteValueARM_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueARM_OpRsh8x8_0(v)
+ return rewriteValueARM_OpRsh8x8(v)
case OpSelect0:
- return rewriteValueARM_OpSelect0_0(v)
+ return rewriteValueARM_OpSelect0(v)
case OpSelect1:
- return rewriteValueARM_OpSelect1_0(v)
+ return rewriteValueARM_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueARM_OpSignExt16to32_0(v)
+ return rewriteValueARM_OpSignExt16to32(v)
case OpSignExt8to16:
- return rewriteValueARM_OpSignExt8to16_0(v)
+ return rewriteValueARM_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueARM_OpSignExt8to32_0(v)
+ return rewriteValueARM_OpSignExt8to32(v)
case OpSignmask:
- return rewriteValueARM_OpSignmask_0(v)
+ return rewriteValueARM_OpSignmask(v)
case OpSlicemask:
- return rewriteValueARM_OpSlicemask_0(v)
+ return rewriteValueARM_OpSlicemask(v)
case OpSqrt:
- return rewriteValueARM_OpSqrt_0(v)
+ return rewriteValueARM_OpSqrt(v)
case OpStaticCall:
- return rewriteValueARM_OpStaticCall_0(v)
+ return rewriteValueARM_OpStaticCall(v)
case OpStore:
- return rewriteValueARM_OpStore_0(v)
+ return rewriteValueARM_OpStore(v)
case OpSub16:
- return rewriteValueARM_OpSub16_0(v)
+ return rewriteValueARM_OpSub16(v)
case OpSub32:
- return rewriteValueARM_OpSub32_0(v)
+ return rewriteValueARM_OpSub32(v)
case OpSub32F:
- return rewriteValueARM_OpSub32F_0(v)
+ return rewriteValueARM_OpSub32F(v)
case OpSub32carry:
- return rewriteValueARM_OpSub32carry_0(v)
+ return rewriteValueARM_OpSub32carry(v)
case OpSub32withcarry:
- return rewriteValueARM_OpSub32withcarry_0(v)
+ return rewriteValueARM_OpSub32withcarry(v)
case OpSub64F:
- return rewriteValueARM_OpSub64F_0(v)
+ return rewriteValueARM_OpSub64F(v)
case OpSub8:
- return rewriteValueARM_OpSub8_0(v)
+ return rewriteValueARM_OpSub8(v)
case OpSubPtr:
- return rewriteValueARM_OpSubPtr_0(v)
+ return rewriteValueARM_OpSubPtr(v)
case OpTrunc16to8:
- return rewriteValueARM_OpTrunc16to8_0(v)
+ return rewriteValueARM_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueARM_OpTrunc32to16_0(v)
+ return rewriteValueARM_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueARM_OpTrunc32to8_0(v)
+ return rewriteValueARM_OpTrunc32to8(v)
case OpWB:
- return rewriteValueARM_OpWB_0(v)
+ return rewriteValueARM_OpWB(v)
case OpXor16:
- return rewriteValueARM_OpXor16_0(v)
+ return rewriteValueARM_OpXor16(v)
case OpXor32:
- return rewriteValueARM_OpXor32_0(v)
+ return rewriteValueARM_OpXor32(v)
case OpXor8:
- return rewriteValueARM_OpXor8_0(v)
+ return rewriteValueARM_OpXor8(v)
case OpZero:
- return rewriteValueARM_OpZero_0(v)
+ return rewriteValueARM_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueARM_OpZeroExt16to32_0(v)
+ return rewriteValueARM_OpZeroExt16to32(v)
case OpZeroExt8to16:
- return rewriteValueARM_OpZeroExt8to16_0(v)
+ return rewriteValueARM_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueARM_OpZeroExt8to32_0(v)
+ return rewriteValueARM_OpZeroExt8to32(v)
case OpZeromask:
- return rewriteValueARM_OpZeromask_0(v)
+ return rewriteValueARM_OpZeromask(v)
}
return false
}
-func rewriteValueARM_OpARMADC_0(v *Value) bool {
+func rewriteValueARM_OpARMADC(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -983,7 +983,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCconst_0(v *Value) bool {
+func rewriteValueARM_OpARMADCconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADCconst [c] (ADDconst [d] x) flags)
@@ -1020,7 +1020,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1062,7 +1062,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1106,7 +1106,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1148,7 +1148,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1192,7 +1192,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1234,7 +1234,7 @@
}
return false
}
-func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1278,7 +1278,7 @@
}
return false
}
-func rewriteValueARM_OpARMADD_0(v *Value) bool {
+func rewriteValueARM_OpARMADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1467,7 +1467,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDD_0(v *Value) bool {
+func rewriteValueARM_OpARMADDD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDD a (MULD x y))
@@ -1516,7 +1516,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDF_0(v *Value) bool {
+func rewriteValueARM_OpARMADDF(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDF a (MULF x y))
@@ -1565,7 +1565,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDS_0(v *Value) bool {
+func rewriteValueARM_OpARMADDS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDS x (MOVWconst [c]))
@@ -1694,7 +1694,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1731,7 +1731,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1770,7 +1770,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1807,7 +1807,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1846,7 +1846,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1883,7 +1883,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1922,7 +1922,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDconst_0(v *Value) bool {
+func rewriteValueARM_OpARMADDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2036,7 +2036,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2123,7 +2123,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2162,7 +2162,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2199,7 +2199,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2238,7 +2238,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2291,7 +2291,7 @@
}
return false
}
-func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2330,7 +2330,7 @@
}
return false
}
-func rewriteValueARM_OpARMAND_0(v *Value) bool {
+func rewriteValueARM_OpARMAND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVWconst [c]))
@@ -2503,11 +2503,6 @@
}
break
}
- return false
-}
-func rewriteValueARM_OpARMAND_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (AND x (MVNshiftRL y [c]))
// result: (BICshiftRL x y [c])
for {
@@ -2546,7 +2541,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDconst_0(v *Value) bool {
+func rewriteValueARM_OpARMANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVWconst [0])
@@ -2628,7 +2623,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2684,7 +2679,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2723,7 +2718,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2779,7 +2774,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2818,7 +2813,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2874,7 +2869,7 @@
}
return false
}
-func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2913,7 +2908,7 @@
}
return false
}
-func rewriteValueARM_OpARMBFX_0(v *Value) bool {
+func rewriteValueARM_OpARMBFX(v *Value) bool {
v_0 := v.Args[0]
// match: (BFX [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8)))])
@@ -2929,7 +2924,7 @@
}
return false
}
-func rewriteValueARM_OpARMBFXU_0(v *Value) bool {
+func rewriteValueARM_OpARMBFXU(v *Value) bool {
v_0 := v.Args[0]
// match: (BFXU [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(uint32(d)<<(32-uint32(c&0xff)-uint32(c>>8))>>(32-uint32(c>>8))))])
@@ -2945,7 +2940,7 @@
}
return false
}
-func rewriteValueARM_OpARMBIC_0(v *Value) bool {
+func rewriteValueARM_OpARMBIC(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BIC x (MOVWconst [c]))
@@ -3064,7 +3059,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICconst_0(v *Value) bool {
+func rewriteValueARM_OpARMBICconst(v *Value) bool {
v_0 := v.Args[0]
// match: (BICconst [0] x)
// result: x
@@ -3146,7 +3141,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftLL x (MOVWconst [c]) [d])
@@ -3182,7 +3177,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3203,7 +3198,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRA x (MOVWconst [c]) [d])
@@ -3239,7 +3234,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3260,7 +3255,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRL x (MOVWconst [c]) [d])
@@ -3296,7 +3291,7 @@
}
return false
}
-func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3317,7 +3312,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMN_0(v *Value) bool {
+func rewriteValueARM_OpARMCMN(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMN x (MOVWconst [c]))
@@ -3462,7 +3457,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNconst_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMNconst (MOVWconst [x]) [y])
// cond: int32(x)==int32(-y)
@@ -3541,7 +3536,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3578,7 +3573,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3617,7 +3612,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3654,7 +3649,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3693,7 +3688,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3730,7 +3725,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMNshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMNshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3769,7 +3764,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVWHSconst _ (FlagEQ) [c])
@@ -3846,7 +3841,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVWLSconst _ (FlagEQ) [c])
@@ -3923,7 +3918,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMP_0(v *Value) bool {
+func rewriteValueARM_OpARMCMP(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4083,12 +4078,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM_OpARMCMP_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (CMP x (SRL y z))
// result: (CMPshiftRLreg x y z)
for {
@@ -4168,7 +4157,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPD_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPD x (MOVDconst [0]))
@@ -4184,7 +4173,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPF_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPF(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMPF x (MOVFconst [0]))
@@ -4200,7 +4189,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPconst_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVWconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -4331,7 +4320,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4370,7 +4359,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4411,7 +4400,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4450,7 +4439,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4491,7 +4480,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4530,7 +4519,7 @@
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4571,7 +4560,7 @@
}
return false
}
-func rewriteValueARM_OpARMEqual_0(v *Value) bool {
+func rewriteValueARM_OpARMEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (Equal (FlagEQ))
// result: (MOVWconst [1])
@@ -4636,7 +4625,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqual (FlagEQ))
// result: (MOVWconst [1])
@@ -4701,7 +4690,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualU (FlagEQ))
// result: (MOVWconst [1])
@@ -4766,7 +4755,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThan(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterThan (FlagEQ))
// result: (MOVWconst [0])
@@ -4831,7 +4820,7 @@
}
return false
}
-func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThanU(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanU (FlagEQ))
// result: (MOVWconst [0])
@@ -4896,7 +4885,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqual_0(v *Value) bool {
+func rewriteValueARM_OpARMLessEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (LessEqual (FlagEQ))
// result: (MOVWconst [1])
@@ -4961,7 +4950,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool {
+func rewriteValueARM_OpARMLessEqualU(v *Value) bool {
v_0 := v.Args[0]
// match: (LessEqualU (FlagEQ))
// result: (MOVWconst [1])
@@ -5026,7 +5015,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThan_0(v *Value) bool {
+func rewriteValueARM_OpARMLessThan(v *Value) bool {
v_0 := v.Args[0]
// match: (LessThan (FlagEQ))
// result: (MOVWconst [0])
@@ -5091,7 +5080,7 @@
}
return false
}
-func rewriteValueARM_OpARMLessThanU_0(v *Value) bool {
+func rewriteValueARM_OpARMLessThanU(v *Value) bool {
v_0 := v.Args[0]
// match: (LessThanU (FlagEQ))
// result: (MOVWconst [0])
@@ -5156,7 +5145,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5278,7 +5267,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUloadidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5336,7 +5325,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(MOVBUload _ _))
// result: (MOVWreg x)
@@ -5387,7 +5376,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5496,7 +5485,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBloadidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5554,7 +5543,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVWreg x)
@@ -5609,7 +5598,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5781,7 +5770,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVBstoreidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVBstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -5822,7 +5811,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -5909,7 +5898,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5980,7 +5969,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVFload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -6067,7 +6056,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVFstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6138,7 +6127,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6262,7 +6251,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUloadidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6320,7 +6309,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x:(MOVBUload _ _))
// result: (MOVWreg x)
@@ -6394,7 +6383,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
@@ -6503,7 +6492,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHloadidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6561,7 +6550,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVWreg x)
@@ -6662,7 +6651,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6796,7 +6785,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVHstoreidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVHstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6837,7 +6826,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWload_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7037,7 +7026,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7198,7 +7187,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7245,7 +7234,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7292,7 +7281,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7339,7 +7328,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x)
// cond: x.Uses == 1
@@ -7366,7 +7355,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7543,7 +7532,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7698,7 +7687,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7723,7 +7712,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7748,7 +7737,7 @@
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -7773,7 +7762,7 @@
}
return false
}
-func rewriteValueARM_OpARMMUL_0(v *Value) bool {
+func rewriteValueARM_OpARMMUL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7983,11 +7972,6 @@
}
break
}
- return false
-}
-func rewriteValueARM_OpARMMUL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MUL (MOVWconst [c]) (MOVWconst [d]))
// result: (MOVWconst [int64(int32(c*d))])
for {
@@ -8008,7 +7992,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULA_0(v *Value) bool {
+func rewriteValueARM_OpARMMULA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8221,13 +8205,6 @@
v.AddArg(a)
return true
}
- return false
-}
-func rewriteValueARM_OpARMMULA_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MULA (MOVWconst [c]) x a)
// cond: int32(c) == -1
// result: (SUB a x)
@@ -8436,12 +8413,6 @@
v.AddArg(a)
return true
}
- return false
-}
-func rewriteValueARM_OpARMMULA_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MULA (MOVWconst [c]) (MOVWconst [d]) a)
// result: (ADDconst [int64(int32(c*d))] a)
for {
@@ -8461,7 +8432,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULD_0(v *Value) bool {
+func rewriteValueARM_OpARMMULD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULD (NEGD x) y)
@@ -8486,7 +8457,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULF_0(v *Value) bool {
+func rewriteValueARM_OpARMMULF(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULF (NEGF x) y)
@@ -8511,7 +8482,7 @@
}
return false
}
-func rewriteValueARM_OpARMMULS_0(v *Value) bool {
+func rewriteValueARM_OpARMMULS(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8724,13 +8695,6 @@
v.AddArg(a)
return true
}
- return false
-}
-func rewriteValueARM_OpARMMULS_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MULS (MOVWconst [c]) x a)
// cond: int32(c) == -1
// result: (ADD a x)
@@ -8939,12 +8903,6 @@
v.AddArg(a)
return true
}
- return false
-}
-func rewriteValueARM_OpARMMULS_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MULS (MOVWconst [c]) (MOVWconst [d]) a)
// result: (SUBconst [int64(int32(c*d))] a)
for {
@@ -8964,7 +8922,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVN_0(v *Value) bool {
+func rewriteValueARM_OpARMMVN(v *Value) bool {
v_0 := v.Args[0]
// match: (MVN (MOVWconst [c]))
// result: (MOVWconst [^c])
@@ -9057,7 +9015,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftLL (MOVWconst [c]) [d])
// result: (MOVWconst [^int64(uint32(c)<<uint64(d))])
@@ -9073,7 +9031,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftLLreg x (MOVWconst [c]))
@@ -9091,7 +9049,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRA (MOVWconst [c]) [d])
// result: (MOVWconst [^int64(int32(c)>>uint64(d))])
@@ -9107,7 +9065,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftRAreg x (MOVWconst [c]))
@@ -9125,7 +9083,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRL (MOVWconst [c]) [d])
// result: (MOVWconst [^int64(uint32(c)>>uint64(d))])
@@ -9141,7 +9099,7 @@
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MVNshiftRLreg x (MOVWconst [c]))
@@ -9159,7 +9117,7 @@
}
return false
}
-func rewriteValueARM_OpARMNEGD_0(v *Value) bool {
+func rewriteValueARM_OpARMNEGD(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGD (MULD x y))
// cond: objabi.GOARM >= 6
@@ -9180,7 +9138,7 @@
}
return false
}
-func rewriteValueARM_OpARMNEGF_0(v *Value) bool {
+func rewriteValueARM_OpARMNEGF(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGF (MULF x y))
// cond: objabi.GOARM >= 6
@@ -9201,7 +9159,7 @@
}
return false
}
-func rewriteValueARM_OpARMNMULD_0(v *Value) bool {
+func rewriteValueARM_OpARMNMULD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NMULD (NEGD x) y)
@@ -9222,7 +9180,7 @@
}
return false
}
-func rewriteValueARM_OpARMNMULF_0(v *Value) bool {
+func rewriteValueARM_OpARMNMULF(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NMULF (NEGF x) y)
@@ -9243,7 +9201,7 @@
}
return false
}
-func rewriteValueARM_OpARMNotEqual_0(v *Value) bool {
+func rewriteValueARM_OpARMNotEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (NotEqual (FlagEQ))
// result: (MOVWconst [0])
@@ -9308,7 +9266,7 @@
}
return false
}
-func rewriteValueARM_OpARMOR_0(v *Value) bool {
+func rewriteValueARM_OpARMOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (MOVWconst [c]))
@@ -9449,7 +9407,7 @@
}
return false
}
-func rewriteValueARM_OpARMORconst_0(v *Value) bool {
+func rewriteValueARM_OpARMORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -9503,7 +9461,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9609,7 +9567,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9648,7 +9606,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9704,7 +9662,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9743,7 +9701,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9815,7 +9773,7 @@
}
return false
}
-func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9854,7 +9812,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSB_0(v *Value) bool {
+func rewriteValueARM_OpARMRSB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RSB (MOVWconst [c]) x)
@@ -10003,11 +9961,6 @@
v.AddArg(z)
return true
}
- return false
-}
-func rewriteValueARM_OpARMRSB_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (RSB x (SRL y z))
// result: (RSBshiftRLreg x y z)
for {
@@ -10100,7 +10053,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10137,7 +10090,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10176,7 +10129,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10213,7 +10166,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10252,7 +10205,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10289,7 +10242,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10328,7 +10281,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBconst_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (RSBconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(c-d))])
@@ -10386,7 +10339,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10440,7 +10393,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10479,7 +10432,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10533,7 +10486,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10572,7 +10525,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10626,7 +10579,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10665,7 +10618,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCconst_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RSCconst [c] (ADDconst [d] x) flags)
@@ -10702,7 +10655,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10744,7 +10697,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10788,7 +10741,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10830,7 +10783,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10874,7 +10827,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10916,7 +10869,7 @@
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10960,7 +10913,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBC_0(v *Value) bool {
+func rewriteValueARM_OpARMSBC(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11130,12 +11083,6 @@
v.AddArg(flags)
return true
}
- return false
-}
-func rewriteValueARM_OpARMSBC_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (SBC x (SRL y z) flags)
// result: (SBCshiftRLreg x y z flags)
for {
@@ -11206,7 +11153,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCconst_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SBCconst [c] (ADDconst [d] x) flags)
@@ -11243,7 +11190,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11285,7 +11232,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11329,7 +11276,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11371,7 +11318,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11415,7 +11362,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11457,7 +11404,7 @@
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11501,7 +11448,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLL_0(v *Value) bool {
+func rewriteValueARM_OpARMSLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVWconst [c]))
@@ -11519,7 +11466,7 @@
}
return false
}
-func rewriteValueARM_OpARMSLLconst_0(v *Value) bool {
+func rewriteValueARM_OpARMSLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(uint32(d)<<uint64(c)))])
@@ -11535,7 +11482,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRA_0(v *Value) bool {
+func rewriteValueARM_OpARMSRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVWconst [c]))
@@ -11553,7 +11500,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAcond_0(v *Value) bool {
+func rewriteValueARM_OpARMSRAcond(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11621,7 +11568,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRAconst_0(v *Value) bool {
+func rewriteValueARM_OpARMSRAconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(d)>>uint64(c))])
@@ -11655,7 +11602,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRL_0(v *Value) bool {
+func rewriteValueARM_OpARMSRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVWconst [c]))
@@ -11673,7 +11620,7 @@
}
return false
}
-func rewriteValueARM_OpARMSRLconst_0(v *Value) bool {
+func rewriteValueARM_OpARMSRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(uint32(d)>>uint64(c)))])
@@ -11707,7 +11654,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUB_0(v *Value) bool {
+func rewriteValueARM_OpARMSUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB (MOVWconst [c]) x)
@@ -11856,11 +11803,6 @@
v.AddArg(z)
return true
}
- return false
-}
-func rewriteValueARM_OpARMSUB_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (SUB x (SRL y z))
// result: (SUBshiftRLreg x y z)
for {
@@ -11953,7 +11895,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBD_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBD a (MULD x y))
@@ -11996,7 +11938,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBF_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBF(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBF a (MULF x y))
@@ -12039,7 +11981,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBS_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBS x (MOVWconst [c]))
@@ -12190,11 +12132,6 @@
v.AddArg(z)
return true
}
- return false
-}
-func rewriteValueARM_OpARMSUBS_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (SUBS (SRL y z) x)
// result: (RSBSshiftRLreg x y z)
for {
@@ -12242,7 +12179,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12279,7 +12216,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12318,7 +12255,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12355,7 +12292,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12394,7 +12331,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12431,7 +12368,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12470,7 +12407,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBconst_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off2-off1] {sym} ptr)
@@ -12584,7 +12521,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12638,7 +12575,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12677,7 +12614,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12731,7 +12668,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12770,7 +12707,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12824,7 +12761,7 @@
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12863,7 +12800,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQ_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQ(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TEQ x (MOVWconst [c]))
@@ -12992,7 +12929,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQconst_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TEQconst (MOVWconst [x]) [y])
// cond: int32(x^y)==0
@@ -13041,7 +12978,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13078,7 +13015,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13117,7 +13054,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13154,7 +13091,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13193,7 +13130,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13230,7 +13167,7 @@
}
return false
}
-func rewriteValueARM_OpARMTEQshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTEQshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13269,7 +13206,7 @@
}
return false
}
-func rewriteValueARM_OpARMTST_0(v *Value) bool {
+func rewriteValueARM_OpARMTST(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TST x (MOVWconst [c]))
@@ -13398,7 +13335,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTconst_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TSTconst (MOVWconst [x]) [y])
// cond: int32(x&y)==0
@@ -13447,7 +13384,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13484,7 +13421,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13523,7 +13460,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13560,7 +13497,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13599,7 +13536,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13636,7 +13573,7 @@
}
return false
}
-func rewriteValueARM_OpARMTSTshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMTSTshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13675,7 +13612,7 @@
}
return false
}
-func rewriteValueARM_OpARMXOR_0(v *Value) bool {
+func rewriteValueARM_OpARMXOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVWconst [c]))
@@ -13833,7 +13770,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORconst_0(v *Value) bool {
+func rewriteValueARM_OpARMXORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -13875,7 +13812,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13979,7 +13916,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14018,7 +13955,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14072,7 +14009,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14111,7 +14048,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14181,7 +14118,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14220,7 +14157,7 @@
}
return false
}
-func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14257,7 +14194,7 @@
}
return false
}
-func rewriteValueARM_OpAbs_0(v *Value) bool {
+func rewriteValueARM_OpAbs(v *Value) bool {
v_0 := v.Args[0]
// match: (Abs x)
// result: (ABSD x)
@@ -14268,7 +14205,7 @@
return true
}
}
-func rewriteValueARM_OpAdd16_0(v *Value) bool {
+func rewriteValueARM_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -14282,7 +14219,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32_0(v *Value) bool {
+func rewriteValueARM_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -14296,7 +14233,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32F_0(v *Value) bool {
+func rewriteValueARM_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -14310,7 +14247,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32carry_0(v *Value) bool {
+func rewriteValueARM_OpAdd32carry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32carry x y)
@@ -14324,7 +14261,7 @@
return true
}
}
-func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool {
+func rewriteValueARM_OpAdd32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14341,7 +14278,7 @@
return true
}
}
-func rewriteValueARM_OpAdd64F_0(v *Value) bool {
+func rewriteValueARM_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -14355,7 +14292,7 @@
return true
}
}
-func rewriteValueARM_OpAdd8_0(v *Value) bool {
+func rewriteValueARM_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -14369,7 +14306,7 @@
return true
}
}
-func rewriteValueARM_OpAddPtr_0(v *Value) bool {
+func rewriteValueARM_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -14383,7 +14320,7 @@
return true
}
}
-func rewriteValueARM_OpAddr_0(v *Value) bool {
+func rewriteValueARM_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVWaddr {sym} base)
@@ -14396,7 +14333,7 @@
return true
}
}
-func rewriteValueARM_OpAnd16_0(v *Value) bool {
+func rewriteValueARM_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -14410,7 +14347,7 @@
return true
}
}
-func rewriteValueARM_OpAnd32_0(v *Value) bool {
+func rewriteValueARM_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -14424,7 +14361,7 @@
return true
}
}
-func rewriteValueARM_OpAnd8_0(v *Value) bool {
+func rewriteValueARM_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -14438,7 +14375,7 @@
return true
}
}
-func rewriteValueARM_OpAndB_0(v *Value) bool {
+func rewriteValueARM_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -14452,7 +14389,7 @@
return true
}
}
-func rewriteValueARM_OpAvg32u_0(v *Value) bool {
+func rewriteValueARM_OpAvg32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14474,7 +14411,7 @@
return true
}
}
-func rewriteValueARM_OpBitLen32_0(v *Value) bool {
+func rewriteValueARM_OpBitLen32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (BitLen32 <t> x)
@@ -14490,7 +14427,7 @@
return true
}
}
-func rewriteValueARM_OpBswap32_0(v *Value) bool {
+func rewriteValueARM_OpBswap32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Bswap32 <t> x)
@@ -14537,7 +14474,7 @@
}
return false
}
-func rewriteValueARM_OpClosureCall_0(v *Value) bool {
+func rewriteValueARM_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14556,7 +14493,7 @@
return true
}
}
-func rewriteValueARM_OpCom16_0(v *Value) bool {
+func rewriteValueARM_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (MVN x)
@@ -14567,7 +14504,7 @@
return true
}
}
-func rewriteValueARM_OpCom32_0(v *Value) bool {
+func rewriteValueARM_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (MVN x)
@@ -14578,7 +14515,7 @@
return true
}
}
-func rewriteValueARM_OpCom8_0(v *Value) bool {
+func rewriteValueARM_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (MVN x)
@@ -14589,7 +14526,7 @@
return true
}
}
-func rewriteValueARM_OpConst16_0(v *Value) bool {
+func rewriteValueARM_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVWconst [val])
for {
@@ -14599,7 +14536,7 @@
return true
}
}
-func rewriteValueARM_OpConst32_0(v *Value) bool {
+func rewriteValueARM_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVWconst [val])
for {
@@ -14609,7 +14546,7 @@
return true
}
}
-func rewriteValueARM_OpConst32F_0(v *Value) bool {
+func rewriteValueARM_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [val])
for {
@@ -14619,7 +14556,7 @@
return true
}
}
-func rewriteValueARM_OpConst64F_0(v *Value) bool {
+func rewriteValueARM_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [val])
for {
@@ -14629,7 +14566,7 @@
return true
}
}
-func rewriteValueARM_OpConst8_0(v *Value) bool {
+func rewriteValueARM_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVWconst [val])
for {
@@ -14639,7 +14576,7 @@
return true
}
}
-func rewriteValueARM_OpConstBool_0(v *Value) bool {
+func rewriteValueARM_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVWconst [b])
for {
@@ -14649,7 +14586,7 @@
return true
}
}
-func rewriteValueARM_OpConstNil_0(v *Value) bool {
+func rewriteValueARM_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVWconst [0])
for {
@@ -14658,7 +14595,7 @@
return true
}
}
-func rewriteValueARM_OpCtz16_0(v *Value) bool {
+func rewriteValueARM_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14714,7 +14651,7 @@
}
return false
}
-func rewriteValueARM_OpCtz16NonZero_0(v *Value) bool {
+func rewriteValueARM_OpCtz16NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz16NonZero x)
// result: (Ctz32 x)
@@ -14725,7 +14662,7 @@
return true
}
}
-func rewriteValueARM_OpCtz32_0(v *Value) bool {
+func rewriteValueARM_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz32 <t> x)
@@ -14771,7 +14708,7 @@
}
return false
}
-func rewriteValueARM_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueARM_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (Ctz32 x)
@@ -14782,7 +14719,7 @@
return true
}
}
-func rewriteValueARM_OpCtz8_0(v *Value) bool {
+func rewriteValueARM_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14838,7 +14775,7 @@
}
return false
}
-func rewriteValueARM_OpCtz8NonZero_0(v *Value) bool {
+func rewriteValueARM_OpCtz8NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz8NonZero x)
// result: (Ctz32 x)
@@ -14849,7 +14786,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (MOVFW x)
@@ -14860,7 +14797,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32U x)
// result: (MOVFWU x)
@@ -14871,7 +14808,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (MOVFD x)
@@ -14882,7 +14819,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Uto32F x)
// result: (MOVWUF x)
@@ -14893,7 +14830,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Uto64F x)
// result: (MOVWUD x)
@@ -14904,7 +14841,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueARM_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (MOVWF x)
@@ -14915,7 +14852,7 @@
return true
}
}
-func rewriteValueARM_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueARM_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (MOVWD x)
@@ -14926,7 +14863,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (MOVDW x)
@@ -14937,7 +14874,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (MOVDF x)
@@ -14948,7 +14885,7 @@
return true
}
}
-func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32U x)
// result: (MOVDWU x)
@@ -14959,7 +14896,7 @@
return true
}
}
-func rewriteValueARM_OpDiv16_0(v *Value) bool {
+func rewriteValueARM_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14979,7 +14916,7 @@
return true
}
}
-func rewriteValueARM_OpDiv16u_0(v *Value) bool {
+func rewriteValueARM_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14999,7 +14936,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32_0(v *Value) bool {
+func rewriteValueARM_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15053,7 +14990,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32F_0(v *Value) bool {
+func rewriteValueARM_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -15067,7 +15004,7 @@
return true
}
}
-func rewriteValueARM_OpDiv32u_0(v *Value) bool {
+func rewriteValueARM_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15086,7 +15023,7 @@
return true
}
}
-func rewriteValueARM_OpDiv64F_0(v *Value) bool {
+func rewriteValueARM_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -15100,7 +15037,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8_0(v *Value) bool {
+func rewriteValueARM_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15120,7 +15057,7 @@
return true
}
}
-func rewriteValueARM_OpDiv8u_0(v *Value) bool {
+func rewriteValueARM_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15140,7 +15077,7 @@
return true
}
}
-func rewriteValueARM_OpEq16_0(v *Value) bool {
+func rewriteValueARM_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15162,7 +15099,7 @@
return true
}
}
-func rewriteValueARM_OpEq32_0(v *Value) bool {
+func rewriteValueARM_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15179,7 +15116,7 @@
return true
}
}
-func rewriteValueARM_OpEq32F_0(v *Value) bool {
+func rewriteValueARM_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15196,7 +15133,7 @@
return true
}
}
-func rewriteValueARM_OpEq64F_0(v *Value) bool {
+func rewriteValueARM_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15213,7 +15150,7 @@
return true
}
}
-func rewriteValueARM_OpEq8_0(v *Value) bool {
+func rewriteValueARM_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15235,7 +15172,7 @@
return true
}
}
-func rewriteValueARM_OpEqB_0(v *Value) bool {
+func rewriteValueARM_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15254,7 +15191,7 @@
return true
}
}
-func rewriteValueARM_OpEqPtr_0(v *Value) bool {
+func rewriteValueARM_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15271,7 +15208,7 @@
return true
}
}
-func rewriteValueARM_OpFMA_0(v *Value) bool {
+func rewriteValueARM_OpFMA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15288,7 +15225,7 @@
return true
}
}
-func rewriteValueARM_OpGeq16_0(v *Value) bool {
+func rewriteValueARM_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15310,7 +15247,7 @@
return true
}
}
-func rewriteValueARM_OpGeq16U_0(v *Value) bool {
+func rewriteValueARM_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15332,7 +15269,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32_0(v *Value) bool {
+func rewriteValueARM_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15349,7 +15286,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32F_0(v *Value) bool {
+func rewriteValueARM_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15366,7 +15303,7 @@
return true
}
}
-func rewriteValueARM_OpGeq32U_0(v *Value) bool {
+func rewriteValueARM_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15383,7 +15320,7 @@
return true
}
}
-func rewriteValueARM_OpGeq64F_0(v *Value) bool {
+func rewriteValueARM_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15400,7 +15337,7 @@
return true
}
}
-func rewriteValueARM_OpGeq8_0(v *Value) bool {
+func rewriteValueARM_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15422,7 +15359,7 @@
return true
}
}
-func rewriteValueARM_OpGeq8U_0(v *Value) bool {
+func rewriteValueARM_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15444,7 +15381,7 @@
return true
}
}
-func rewriteValueARM_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueARM_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -15452,7 +15389,7 @@
return true
}
}
-func rewriteValueARM_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueARM_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -15460,7 +15397,7 @@
return true
}
}
-func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueARM_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -15468,7 +15405,7 @@
return true
}
}
-func rewriteValueARM_OpGreater16_0(v *Value) bool {
+func rewriteValueARM_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15490,7 +15427,7 @@
return true
}
}
-func rewriteValueARM_OpGreater16U_0(v *Value) bool {
+func rewriteValueARM_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15512,7 +15449,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32_0(v *Value) bool {
+func rewriteValueARM_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15529,7 +15466,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32F_0(v *Value) bool {
+func rewriteValueARM_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15546,7 +15483,7 @@
return true
}
}
-func rewriteValueARM_OpGreater32U_0(v *Value) bool {
+func rewriteValueARM_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15563,7 +15500,7 @@
return true
}
}
-func rewriteValueARM_OpGreater64F_0(v *Value) bool {
+func rewriteValueARM_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15580,7 +15517,7 @@
return true
}
}
-func rewriteValueARM_OpGreater8_0(v *Value) bool {
+func rewriteValueARM_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15602,7 +15539,7 @@
return true
}
}
-func rewriteValueARM_OpGreater8U_0(v *Value) bool {
+func rewriteValueARM_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15624,7 +15561,7 @@
return true
}
}
-func rewriteValueARM_OpHmul32_0(v *Value) bool {
+func rewriteValueARM_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32 x y)
@@ -15638,7 +15575,7 @@
return true
}
}
-func rewriteValueARM_OpHmul32u_0(v *Value) bool {
+func rewriteValueARM_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32u x y)
@@ -15652,7 +15589,7 @@
return true
}
}
-func rewriteValueARM_OpInterCall_0(v *Value) bool {
+func rewriteValueARM_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -15668,7 +15605,7 @@
return true
}
}
-func rewriteValueARM_OpIsInBounds_0(v *Value) bool {
+func rewriteValueARM_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15685,7 +15622,7 @@
return true
}
}
-func rewriteValueARM_OpIsNonNil_0(v *Value) bool {
+func rewriteValueARM_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -15700,7 +15637,7 @@
return true
}
}
-func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueARM_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15717,7 +15654,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16_0(v *Value) bool {
+func rewriteValueARM_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15739,7 +15676,7 @@
return true
}
}
-func rewriteValueARM_OpLeq16U_0(v *Value) bool {
+func rewriteValueARM_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15761,7 +15698,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32_0(v *Value) bool {
+func rewriteValueARM_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15778,7 +15715,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32F_0(v *Value) bool {
+func rewriteValueARM_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15795,7 +15732,7 @@
return true
}
}
-func rewriteValueARM_OpLeq32U_0(v *Value) bool {
+func rewriteValueARM_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15812,7 +15749,7 @@
return true
}
}
-func rewriteValueARM_OpLeq64F_0(v *Value) bool {
+func rewriteValueARM_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15829,7 +15766,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8_0(v *Value) bool {
+func rewriteValueARM_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15851,7 +15788,7 @@
return true
}
}
-func rewriteValueARM_OpLeq8U_0(v *Value) bool {
+func rewriteValueARM_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15873,7 +15810,7 @@
return true
}
}
-func rewriteValueARM_OpLess16_0(v *Value) bool {
+func rewriteValueARM_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15895,7 +15832,7 @@
return true
}
}
-func rewriteValueARM_OpLess16U_0(v *Value) bool {
+func rewriteValueARM_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15917,7 +15854,7 @@
return true
}
}
-func rewriteValueARM_OpLess32_0(v *Value) bool {
+func rewriteValueARM_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15934,7 +15871,7 @@
return true
}
}
-func rewriteValueARM_OpLess32F_0(v *Value) bool {
+func rewriteValueARM_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15951,7 +15888,7 @@
return true
}
}
-func rewriteValueARM_OpLess32U_0(v *Value) bool {
+func rewriteValueARM_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15968,7 +15905,7 @@
return true
}
}
-func rewriteValueARM_OpLess64F_0(v *Value) bool {
+func rewriteValueARM_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15985,7 +15922,7 @@
return true
}
}
-func rewriteValueARM_OpLess8_0(v *Value) bool {
+func rewriteValueARM_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16007,7 +15944,7 @@
return true
}
}
-func rewriteValueARM_OpLess8U_0(v *Value) bool {
+func rewriteValueARM_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16029,7 +15966,7 @@
return true
}
}
-func rewriteValueARM_OpLoad_0(v *Value) bool {
+func rewriteValueARM_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -16154,7 +16091,7 @@
}
return false
}
-func rewriteValueARM_OpLocalAddr_0(v *Value) bool {
+func rewriteValueARM_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVWaddr {sym} base)
@@ -16167,7 +16104,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x16_0(v *Value) bool {
+func rewriteValueARM_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16194,7 +16131,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x32_0(v *Value) bool {
+func rewriteValueARM_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16216,7 +16153,7 @@
return true
}
}
-func rewriteValueARM_OpLsh16x64_0(v *Value) bool {
+func rewriteValueARM_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -16253,7 +16190,7 @@
}
return false
}
-func rewriteValueARM_OpLsh16x8_0(v *Value) bool {
+func rewriteValueARM_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16271,7 +16208,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x16_0(v *Value) bool {
+func rewriteValueARM_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16298,7 +16235,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x32_0(v *Value) bool {
+func rewriteValueARM_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16320,7 +16257,7 @@
return true
}
}
-func rewriteValueARM_OpLsh32x64_0(v *Value) bool {
+func rewriteValueARM_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -16357,7 +16294,7 @@
}
return false
}
-func rewriteValueARM_OpLsh32x8_0(v *Value) bool {
+func rewriteValueARM_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16375,7 +16312,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x16_0(v *Value) bool {
+func rewriteValueARM_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16402,7 +16339,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x32_0(v *Value) bool {
+func rewriteValueARM_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16424,7 +16361,7 @@
return true
}
}
-func rewriteValueARM_OpLsh8x64_0(v *Value) bool {
+func rewriteValueARM_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -16461,7 +16398,7 @@
}
return false
}
-func rewriteValueARM_OpLsh8x8_0(v *Value) bool {
+func rewriteValueARM_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16479,7 +16416,7 @@
return true
}
}
-func rewriteValueARM_OpMod16_0(v *Value) bool {
+func rewriteValueARM_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16499,7 +16436,7 @@
return true
}
}
-func rewriteValueARM_OpMod16u_0(v *Value) bool {
+func rewriteValueARM_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16519,7 +16456,7 @@
return true
}
}
-func rewriteValueARM_OpMod32_0(v *Value) bool {
+func rewriteValueARM_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16567,7 +16504,7 @@
return true
}
}
-func rewriteValueARM_OpMod32u_0(v *Value) bool {
+func rewriteValueARM_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16586,7 +16523,7 @@
return true
}
}
-func rewriteValueARM_OpMod8_0(v *Value) bool {
+func rewriteValueARM_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16606,7 +16543,7 @@
return true
}
}
-func rewriteValueARM_OpMod8u_0(v *Value) bool {
+func rewriteValueARM_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16626,7 +16563,7 @@
return true
}
}
-func rewriteValueARM_OpMove_0(v *Value) bool {
+func rewriteValueARM_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16893,7 +16830,7 @@
}
return false
}
-func rewriteValueARM_OpMul16_0(v *Value) bool {
+func rewriteValueARM_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -16907,7 +16844,7 @@
return true
}
}
-func rewriteValueARM_OpMul32_0(v *Value) bool {
+func rewriteValueARM_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -16921,7 +16858,7 @@
return true
}
}
-func rewriteValueARM_OpMul32F_0(v *Value) bool {
+func rewriteValueARM_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -16935,7 +16872,7 @@
return true
}
}
-func rewriteValueARM_OpMul32uhilo_0(v *Value) bool {
+func rewriteValueARM_OpMul32uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32uhilo x y)
@@ -16949,7 +16886,7 @@
return true
}
}
-func rewriteValueARM_OpMul64F_0(v *Value) bool {
+func rewriteValueARM_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -16963,7 +16900,7 @@
return true
}
}
-func rewriteValueARM_OpMul8_0(v *Value) bool {
+func rewriteValueARM_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -16977,7 +16914,7 @@
return true
}
}
-func rewriteValueARM_OpNeg16_0(v *Value) bool {
+func rewriteValueARM_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (RSBconst [0] x)
@@ -16989,7 +16926,7 @@
return true
}
}
-func rewriteValueARM_OpNeg32_0(v *Value) bool {
+func rewriteValueARM_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (RSBconst [0] x)
@@ -17001,7 +16938,7 @@
return true
}
}
-func rewriteValueARM_OpNeg32F_0(v *Value) bool {
+func rewriteValueARM_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (NEGF x)
@@ -17012,7 +16949,7 @@
return true
}
}
-func rewriteValueARM_OpNeg64F_0(v *Value) bool {
+func rewriteValueARM_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (NEGD x)
@@ -17023,7 +16960,7 @@
return true
}
}
-func rewriteValueARM_OpNeg8_0(v *Value) bool {
+func rewriteValueARM_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (RSBconst [0] x)
@@ -17035,7 +16972,7 @@
return true
}
}
-func rewriteValueARM_OpNeq16_0(v *Value) bool {
+func rewriteValueARM_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17057,7 +16994,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32_0(v *Value) bool {
+func rewriteValueARM_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17074,7 +17011,7 @@
return true
}
}
-func rewriteValueARM_OpNeq32F_0(v *Value) bool {
+func rewriteValueARM_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17091,7 +17028,7 @@
return true
}
}
-func rewriteValueARM_OpNeq64F_0(v *Value) bool {
+func rewriteValueARM_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17108,7 +17045,7 @@
return true
}
}
-func rewriteValueARM_OpNeq8_0(v *Value) bool {
+func rewriteValueARM_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17130,7 +17067,7 @@
return true
}
}
-func rewriteValueARM_OpNeqB_0(v *Value) bool {
+func rewriteValueARM_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -17144,7 +17081,7 @@
return true
}
}
-func rewriteValueARM_OpNeqPtr_0(v *Value) bool {
+func rewriteValueARM_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17161,7 +17098,7 @@
return true
}
}
-func rewriteValueARM_OpNilCheck_0(v *Value) bool {
+func rewriteValueARM_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -17175,7 +17112,7 @@
return true
}
}
-func rewriteValueARM_OpNot_0(v *Value) bool {
+func rewriteValueARM_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -17187,7 +17124,7 @@
return true
}
}
-func rewriteValueARM_OpOffPtr_0(v *Value) bool {
+func rewriteValueARM_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVWaddr [off] ptr)
@@ -17213,7 +17150,7 @@
return true
}
}
-func rewriteValueARM_OpOr16_0(v *Value) bool {
+func rewriteValueARM_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -17227,7 +17164,7 @@
return true
}
}
-func rewriteValueARM_OpOr32_0(v *Value) bool {
+func rewriteValueARM_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -17241,7 +17178,7 @@
return true
}
}
-func rewriteValueARM_OpOr8_0(v *Value) bool {
+func rewriteValueARM_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -17255,7 +17192,7 @@
return true
}
}
-func rewriteValueARM_OpOrB_0(v *Value) bool {
+func rewriteValueARM_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -17269,7 +17206,7 @@
return true
}
}
-func rewriteValueARM_OpPanicBounds_0(v *Value) bool {
+func rewriteValueARM_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17329,7 +17266,7 @@
}
return false
}
-func rewriteValueARM_OpPanicExtend_0(v *Value) bool {
+func rewriteValueARM_OpPanicExtend(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -17396,7 +17333,7 @@
}
return false
}
-func rewriteValueARM_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueARM_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17427,7 +17364,7 @@
}
return false
}
-func rewriteValueARM_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueARM_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17458,7 +17395,7 @@
return true
}
}
-func rewriteValueARM_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueARM_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17489,7 +17426,7 @@
}
return false
}
-func rewriteValueARM_OpRound32F_0(v *Value) bool {
+func rewriteValueARM_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -17501,7 +17438,7 @@
return true
}
}
-func rewriteValueARM_OpRound64F_0(v *Value) bool {
+func rewriteValueARM_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -17513,7 +17450,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17542,7 +17479,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17567,7 +17504,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17609,7 +17546,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17629,7 +17566,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x16_0(v *Value) bool {
+func rewriteValueARM_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17655,7 +17592,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x32_0(v *Value) bool {
+func rewriteValueARM_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17677,7 +17614,7 @@
return true
}
}
-func rewriteValueARM_OpRsh16x64_0(v *Value) bool {
+func rewriteValueARM_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17724,7 +17661,7 @@
}
return false
}
-func rewriteValueARM_OpRsh16x8_0(v *Value) bool {
+func rewriteValueARM_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17744,7 +17681,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17771,7 +17708,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17793,7 +17730,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -17830,7 +17767,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17848,7 +17785,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x16_0(v *Value) bool {
+func rewriteValueARM_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17872,7 +17809,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x32_0(v *Value) bool {
+func rewriteValueARM_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17891,7 +17828,7 @@
return true
}
}
-func rewriteValueARM_OpRsh32x64_0(v *Value) bool {
+func rewriteValueARM_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -17930,7 +17867,7 @@
}
return false
}
-func rewriteValueARM_OpRsh32x8_0(v *Value) bool {
+func rewriteValueARM_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17948,7 +17885,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17977,7 +17914,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18002,7 +17939,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18044,7 +17981,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18064,7 +18001,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x16_0(v *Value) bool {
+func rewriteValueARM_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18090,7 +18027,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x32_0(v *Value) bool {
+func rewriteValueARM_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18112,7 +18049,7 @@
return true
}
}
-func rewriteValueARM_OpRsh8x64_0(v *Value) bool {
+func rewriteValueARM_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18159,7 +18096,7 @@
}
return false
}
-func rewriteValueARM_OpRsh8x8_0(v *Value) bool {
+func rewriteValueARM_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18179,7 +18116,7 @@
return true
}
}
-func rewriteValueARM_OpSelect0_0(v *Value) bool {
+func rewriteValueARM_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
// match: (Select0 (CALLudiv x (MOVWconst [1])))
// result: x
@@ -18243,7 +18180,7 @@
}
return false
}
-func rewriteValueARM_OpSelect1_0(v *Value) bool {
+func rewriteValueARM_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
// match: (Select1 (CALLudiv _ (MOVWconst [1])))
// result: (MOVWconst [0])
@@ -18305,7 +18242,7 @@
}
return false
}
-func rewriteValueARM_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueARM_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -18316,7 +18253,7 @@
return true
}
}
-func rewriteValueARM_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueARM_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -18327,7 +18264,7 @@
return true
}
}
-func rewriteValueARM_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueARM_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -18338,7 +18275,7 @@
return true
}
}
-func rewriteValueARM_OpSignmask_0(v *Value) bool {
+func rewriteValueARM_OpSignmask(v *Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SRAconst x [31])
@@ -18350,7 +18287,7 @@
return true
}
}
-func rewriteValueARM_OpSlicemask_0(v *Value) bool {
+func rewriteValueARM_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -18367,7 +18304,7 @@
return true
}
}
-func rewriteValueARM_OpSqrt_0(v *Value) bool {
+func rewriteValueARM_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (SQRTD x)
@@ -18378,7 +18315,7 @@
return true
}
}
-func rewriteValueARM_OpStaticCall_0(v *Value) bool {
+func rewriteValueARM_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -18393,7 +18330,7 @@
return true
}
}
-func rewriteValueARM_OpStore_0(v *Value) bool {
+func rewriteValueARM_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18484,7 +18421,7 @@
}
return false
}
-func rewriteValueARM_OpSub16_0(v *Value) bool {
+func rewriteValueARM_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -18498,7 +18435,7 @@
return true
}
}
-func rewriteValueARM_OpSub32_0(v *Value) bool {
+func rewriteValueARM_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -18512,7 +18449,7 @@
return true
}
}
-func rewriteValueARM_OpSub32F_0(v *Value) bool {
+func rewriteValueARM_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -18526,7 +18463,7 @@
return true
}
}
-func rewriteValueARM_OpSub32carry_0(v *Value) bool {
+func rewriteValueARM_OpSub32carry(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32carry x y)
@@ -18540,7 +18477,7 @@
return true
}
}
-func rewriteValueARM_OpSub32withcarry_0(v *Value) bool {
+func rewriteValueARM_OpSub32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18557,7 +18494,7 @@
return true
}
}
-func rewriteValueARM_OpSub64F_0(v *Value) bool {
+func rewriteValueARM_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -18571,7 +18508,7 @@
return true
}
}
-func rewriteValueARM_OpSub8_0(v *Value) bool {
+func rewriteValueARM_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -18585,7 +18522,7 @@
return true
}
}
-func rewriteValueARM_OpSubPtr_0(v *Value) bool {
+func rewriteValueARM_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -18599,7 +18536,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueARM_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -18611,7 +18548,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueARM_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -18623,7 +18560,7 @@
return true
}
}
-func rewriteValueARM_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueARM_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -18635,7 +18572,7 @@
return true
}
}
-func rewriteValueARM_OpWB_0(v *Value) bool {
+func rewriteValueARM_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -18654,7 +18591,7 @@
return true
}
}
-func rewriteValueARM_OpXor16_0(v *Value) bool {
+func rewriteValueARM_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -18668,7 +18605,7 @@
return true
}
}
-func rewriteValueARM_OpXor32_0(v *Value) bool {
+func rewriteValueARM_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -18682,7 +18619,7 @@
return true
}
}
-func rewriteValueARM_OpXor8_0(v *Value) bool {
+func rewriteValueARM_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -18696,7 +18633,7 @@
return true
}
}
-func rewriteValueARM_OpZero_0(v *Value) bool {
+func rewriteValueARM_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18940,7 +18877,7 @@
}
return false
}
-func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueARM_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHUreg x)
@@ -18951,7 +18888,7 @@
return true
}
}
-func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBUreg x)
@@ -18962,7 +18899,7 @@
return true
}
}
-func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBUreg x)
@@ -18973,7 +18910,7 @@
return true
}
}
-func rewriteValueARM_OpZeromask_0(v *Value) bool {
+func rewriteValueARM_OpZeromask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go
index 87e15d9..6e69eab 100644
--- a/src/cmd/compile/internal/ssa/rewriteARM64.go
+++ b/src/cmd/compile/internal/ssa/rewriteARM64.go
@@ -8,955 +8,955 @@
func rewriteValueARM64(v *Value) bool {
switch v.Op {
case OpARM64ADCSflags:
- return rewriteValueARM64_OpARM64ADCSflags_0(v)
+ return rewriteValueARM64_OpARM64ADCSflags(v)
case OpARM64ADD:
- return rewriteValueARM64_OpARM64ADD_0(v) || rewriteValueARM64_OpARM64ADD_10(v)
+ return rewriteValueARM64_OpARM64ADD(v)
case OpARM64ADDconst:
- return rewriteValueARM64_OpARM64ADDconst_0(v)
+ return rewriteValueARM64_OpARM64ADDconst(v)
case OpARM64ADDshiftLL:
- return rewriteValueARM64_OpARM64ADDshiftLL_0(v)
+ return rewriteValueARM64_OpARM64ADDshiftLL(v)
case OpARM64ADDshiftRA:
- return rewriteValueARM64_OpARM64ADDshiftRA_0(v)
+ return rewriteValueARM64_OpARM64ADDshiftRA(v)
case OpARM64ADDshiftRL:
- return rewriteValueARM64_OpARM64ADDshiftRL_0(v)
+ return rewriteValueARM64_OpARM64ADDshiftRL(v)
case OpARM64AND:
- return rewriteValueARM64_OpARM64AND_0(v)
+ return rewriteValueARM64_OpARM64AND(v)
case OpARM64ANDconst:
- return rewriteValueARM64_OpARM64ANDconst_0(v)
+ return rewriteValueARM64_OpARM64ANDconst(v)
case OpARM64ANDshiftLL:
- return rewriteValueARM64_OpARM64ANDshiftLL_0(v)
+ return rewriteValueARM64_OpARM64ANDshiftLL(v)
case OpARM64ANDshiftRA:
- return rewriteValueARM64_OpARM64ANDshiftRA_0(v)
+ return rewriteValueARM64_OpARM64ANDshiftRA(v)
case OpARM64ANDshiftRL:
- return rewriteValueARM64_OpARM64ANDshiftRL_0(v)
+ return rewriteValueARM64_OpARM64ANDshiftRL(v)
case OpARM64BIC:
- return rewriteValueARM64_OpARM64BIC_0(v)
+ return rewriteValueARM64_OpARM64BIC(v)
case OpARM64BICshiftLL:
- return rewriteValueARM64_OpARM64BICshiftLL_0(v)
+ return rewriteValueARM64_OpARM64BICshiftLL(v)
case OpARM64BICshiftRA:
- return rewriteValueARM64_OpARM64BICshiftRA_0(v)
+ return rewriteValueARM64_OpARM64BICshiftRA(v)
case OpARM64BICshiftRL:
- return rewriteValueARM64_OpARM64BICshiftRL_0(v)
+ return rewriteValueARM64_OpARM64BICshiftRL(v)
case OpARM64CMN:
- return rewriteValueARM64_OpARM64CMN_0(v)
+ return rewriteValueARM64_OpARM64CMN(v)
case OpARM64CMNW:
- return rewriteValueARM64_OpARM64CMNW_0(v)
+ return rewriteValueARM64_OpARM64CMNW(v)
case OpARM64CMNWconst:
- return rewriteValueARM64_OpARM64CMNWconst_0(v)
+ return rewriteValueARM64_OpARM64CMNWconst(v)
case OpARM64CMNconst:
- return rewriteValueARM64_OpARM64CMNconst_0(v)
+ return rewriteValueARM64_OpARM64CMNconst(v)
case OpARM64CMNshiftLL:
- return rewriteValueARM64_OpARM64CMNshiftLL_0(v)
+ return rewriteValueARM64_OpARM64CMNshiftLL(v)
case OpARM64CMNshiftRA:
- return rewriteValueARM64_OpARM64CMNshiftRA_0(v)
+ return rewriteValueARM64_OpARM64CMNshiftRA(v)
case OpARM64CMNshiftRL:
- return rewriteValueARM64_OpARM64CMNshiftRL_0(v)
+ return rewriteValueARM64_OpARM64CMNshiftRL(v)
case OpARM64CMP:
- return rewriteValueARM64_OpARM64CMP_0(v)
+ return rewriteValueARM64_OpARM64CMP(v)
case OpARM64CMPW:
- return rewriteValueARM64_OpARM64CMPW_0(v)
+ return rewriteValueARM64_OpARM64CMPW(v)
case OpARM64CMPWconst:
- return rewriteValueARM64_OpARM64CMPWconst_0(v)
+ return rewriteValueARM64_OpARM64CMPWconst(v)
case OpARM64CMPconst:
- return rewriteValueARM64_OpARM64CMPconst_0(v)
+ return rewriteValueARM64_OpARM64CMPconst(v)
case OpARM64CMPshiftLL:
- return rewriteValueARM64_OpARM64CMPshiftLL_0(v)
+ return rewriteValueARM64_OpARM64CMPshiftLL(v)
case OpARM64CMPshiftRA:
- return rewriteValueARM64_OpARM64CMPshiftRA_0(v)
+ return rewriteValueARM64_OpARM64CMPshiftRA(v)
case OpARM64CMPshiftRL:
- return rewriteValueARM64_OpARM64CMPshiftRL_0(v)
+ return rewriteValueARM64_OpARM64CMPshiftRL(v)
case OpARM64CSEL:
- return rewriteValueARM64_OpARM64CSEL_0(v)
+ return rewriteValueARM64_OpARM64CSEL(v)
case OpARM64CSEL0:
- return rewriteValueARM64_OpARM64CSEL0_0(v)
+ return rewriteValueARM64_OpARM64CSEL0(v)
case OpARM64DIV:
- return rewriteValueARM64_OpARM64DIV_0(v)
+ return rewriteValueARM64_OpARM64DIV(v)
case OpARM64DIVW:
- return rewriteValueARM64_OpARM64DIVW_0(v)
+ return rewriteValueARM64_OpARM64DIVW(v)
case OpARM64EON:
- return rewriteValueARM64_OpARM64EON_0(v)
+ return rewriteValueARM64_OpARM64EON(v)
case OpARM64EONshiftLL:
- return rewriteValueARM64_OpARM64EONshiftLL_0(v)
+ return rewriteValueARM64_OpARM64EONshiftLL(v)
case OpARM64EONshiftRA:
- return rewriteValueARM64_OpARM64EONshiftRA_0(v)
+ return rewriteValueARM64_OpARM64EONshiftRA(v)
case OpARM64EONshiftRL:
- return rewriteValueARM64_OpARM64EONshiftRL_0(v)
+ return rewriteValueARM64_OpARM64EONshiftRL(v)
case OpARM64Equal:
- return rewriteValueARM64_OpARM64Equal_0(v)
+ return rewriteValueARM64_OpARM64Equal(v)
case OpARM64FADDD:
- return rewriteValueARM64_OpARM64FADDD_0(v)
+ return rewriteValueARM64_OpARM64FADDD(v)
case OpARM64FADDS:
- return rewriteValueARM64_OpARM64FADDS_0(v)
+ return rewriteValueARM64_OpARM64FADDS(v)
case OpARM64FCMPD:
- return rewriteValueARM64_OpARM64FCMPD_0(v)
+ return rewriteValueARM64_OpARM64FCMPD(v)
case OpARM64FCMPS:
- return rewriteValueARM64_OpARM64FCMPS_0(v)
+ return rewriteValueARM64_OpARM64FCMPS(v)
case OpARM64FMOVDfpgp:
- return rewriteValueARM64_OpARM64FMOVDfpgp_0(v)
+ return rewriteValueARM64_OpARM64FMOVDfpgp(v)
case OpARM64FMOVDgpfp:
- return rewriteValueARM64_OpARM64FMOVDgpfp_0(v)
+ return rewriteValueARM64_OpARM64FMOVDgpfp(v)
case OpARM64FMOVDload:
- return rewriteValueARM64_OpARM64FMOVDload_0(v)
+ return rewriteValueARM64_OpARM64FMOVDload(v)
case OpARM64FMOVDloadidx:
- return rewriteValueARM64_OpARM64FMOVDloadidx_0(v)
+ return rewriteValueARM64_OpARM64FMOVDloadidx(v)
case OpARM64FMOVDstore:
- return rewriteValueARM64_OpARM64FMOVDstore_0(v)
+ return rewriteValueARM64_OpARM64FMOVDstore(v)
case OpARM64FMOVDstoreidx:
- return rewriteValueARM64_OpARM64FMOVDstoreidx_0(v)
+ return rewriteValueARM64_OpARM64FMOVDstoreidx(v)
case OpARM64FMOVSload:
- return rewriteValueARM64_OpARM64FMOVSload_0(v)
+ return rewriteValueARM64_OpARM64FMOVSload(v)
case OpARM64FMOVSloadidx:
- return rewriteValueARM64_OpARM64FMOVSloadidx_0(v)
+ return rewriteValueARM64_OpARM64FMOVSloadidx(v)
case OpARM64FMOVSstore:
- return rewriteValueARM64_OpARM64FMOVSstore_0(v)
+ return rewriteValueARM64_OpARM64FMOVSstore(v)
case OpARM64FMOVSstoreidx:
- return rewriteValueARM64_OpARM64FMOVSstoreidx_0(v)
+ return rewriteValueARM64_OpARM64FMOVSstoreidx(v)
case OpARM64FMULD:
- return rewriteValueARM64_OpARM64FMULD_0(v)
+ return rewriteValueARM64_OpARM64FMULD(v)
case OpARM64FMULS:
- return rewriteValueARM64_OpARM64FMULS_0(v)
+ return rewriteValueARM64_OpARM64FMULS(v)
case OpARM64FNEGD:
- return rewriteValueARM64_OpARM64FNEGD_0(v)
+ return rewriteValueARM64_OpARM64FNEGD(v)
case OpARM64FNEGS:
- return rewriteValueARM64_OpARM64FNEGS_0(v)
+ return rewriteValueARM64_OpARM64FNEGS(v)
case OpARM64FNMULD:
- return rewriteValueARM64_OpARM64FNMULD_0(v)
+ return rewriteValueARM64_OpARM64FNMULD(v)
case OpARM64FNMULS:
- return rewriteValueARM64_OpARM64FNMULS_0(v)
+ return rewriteValueARM64_OpARM64FNMULS(v)
case OpARM64FSUBD:
- return rewriteValueARM64_OpARM64FSUBD_0(v)
+ return rewriteValueARM64_OpARM64FSUBD(v)
case OpARM64FSUBS:
- return rewriteValueARM64_OpARM64FSUBS_0(v)
+ return rewriteValueARM64_OpARM64FSUBS(v)
case OpARM64GreaterEqual:
- return rewriteValueARM64_OpARM64GreaterEqual_0(v)
+ return rewriteValueARM64_OpARM64GreaterEqual(v)
case OpARM64GreaterEqualF:
- return rewriteValueARM64_OpARM64GreaterEqualF_0(v)
+ return rewriteValueARM64_OpARM64GreaterEqualF(v)
case OpARM64GreaterEqualU:
- return rewriteValueARM64_OpARM64GreaterEqualU_0(v)
+ return rewriteValueARM64_OpARM64GreaterEqualU(v)
case OpARM64GreaterThan:
- return rewriteValueARM64_OpARM64GreaterThan_0(v)
+ return rewriteValueARM64_OpARM64GreaterThan(v)
case OpARM64GreaterThanF:
- return rewriteValueARM64_OpARM64GreaterThanF_0(v)
+ return rewriteValueARM64_OpARM64GreaterThanF(v)
case OpARM64GreaterThanU:
- return rewriteValueARM64_OpARM64GreaterThanU_0(v)
+ return rewriteValueARM64_OpARM64GreaterThanU(v)
case OpARM64LessEqual:
- return rewriteValueARM64_OpARM64LessEqual_0(v)
+ return rewriteValueARM64_OpARM64LessEqual(v)
case OpARM64LessEqualF:
- return rewriteValueARM64_OpARM64LessEqualF_0(v)
+ return rewriteValueARM64_OpARM64LessEqualF(v)
case OpARM64LessEqualU:
- return rewriteValueARM64_OpARM64LessEqualU_0(v)
+ return rewriteValueARM64_OpARM64LessEqualU(v)
case OpARM64LessThan:
- return rewriteValueARM64_OpARM64LessThan_0(v)
+ return rewriteValueARM64_OpARM64LessThan(v)
case OpARM64LessThanF:
- return rewriteValueARM64_OpARM64LessThanF_0(v)
+ return rewriteValueARM64_OpARM64LessThanF(v)
case OpARM64LessThanU:
- return rewriteValueARM64_OpARM64LessThanU_0(v)
+ return rewriteValueARM64_OpARM64LessThanU(v)
case OpARM64MADD:
- return rewriteValueARM64_OpARM64MADD_0(v) || rewriteValueARM64_OpARM64MADD_10(v) || rewriteValueARM64_OpARM64MADD_20(v)
+ return rewriteValueARM64_OpARM64MADD(v)
case OpARM64MADDW:
- return rewriteValueARM64_OpARM64MADDW_0(v) || rewriteValueARM64_OpARM64MADDW_10(v) || rewriteValueARM64_OpARM64MADDW_20(v)
+ return rewriteValueARM64_OpARM64MADDW(v)
case OpARM64MNEG:
- return rewriteValueARM64_OpARM64MNEG_0(v) || rewriteValueARM64_OpARM64MNEG_10(v)
+ return rewriteValueARM64_OpARM64MNEG(v)
case OpARM64MNEGW:
- return rewriteValueARM64_OpARM64MNEGW_0(v) || rewriteValueARM64_OpARM64MNEGW_10(v)
+ return rewriteValueARM64_OpARM64MNEGW(v)
case OpARM64MOD:
- return rewriteValueARM64_OpARM64MOD_0(v)
+ return rewriteValueARM64_OpARM64MOD(v)
case OpARM64MODW:
- return rewriteValueARM64_OpARM64MODW_0(v)
+ return rewriteValueARM64_OpARM64MODW(v)
case OpARM64MOVBUload:
- return rewriteValueARM64_OpARM64MOVBUload_0(v)
+ return rewriteValueARM64_OpARM64MOVBUload(v)
case OpARM64MOVBUloadidx:
- return rewriteValueARM64_OpARM64MOVBUloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVBUloadidx(v)
case OpARM64MOVBUreg:
- return rewriteValueARM64_OpARM64MOVBUreg_0(v)
+ return rewriteValueARM64_OpARM64MOVBUreg(v)
case OpARM64MOVBload:
- return rewriteValueARM64_OpARM64MOVBload_0(v)
+ return rewriteValueARM64_OpARM64MOVBload(v)
case OpARM64MOVBloadidx:
- return rewriteValueARM64_OpARM64MOVBloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVBloadidx(v)
case OpARM64MOVBreg:
- return rewriteValueARM64_OpARM64MOVBreg_0(v)
+ return rewriteValueARM64_OpARM64MOVBreg(v)
case OpARM64MOVBstore:
- return rewriteValueARM64_OpARM64MOVBstore_0(v) || rewriteValueARM64_OpARM64MOVBstore_10(v) || rewriteValueARM64_OpARM64MOVBstore_20(v) || rewriteValueARM64_OpARM64MOVBstore_30(v)
+ return rewriteValueARM64_OpARM64MOVBstore(v)
case OpARM64MOVBstoreidx:
- return rewriteValueARM64_OpARM64MOVBstoreidx_0(v) || rewriteValueARM64_OpARM64MOVBstoreidx_10(v)
+ return rewriteValueARM64_OpARM64MOVBstoreidx(v)
case OpARM64MOVBstorezero:
- return rewriteValueARM64_OpARM64MOVBstorezero_0(v)
+ return rewriteValueARM64_OpARM64MOVBstorezero(v)
case OpARM64MOVBstorezeroidx:
- return rewriteValueARM64_OpARM64MOVBstorezeroidx_0(v)
+ return rewriteValueARM64_OpARM64MOVBstorezeroidx(v)
case OpARM64MOVDload:
- return rewriteValueARM64_OpARM64MOVDload_0(v)
+ return rewriteValueARM64_OpARM64MOVDload(v)
case OpARM64MOVDloadidx:
- return rewriteValueARM64_OpARM64MOVDloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVDloadidx(v)
case OpARM64MOVDloadidx8:
- return rewriteValueARM64_OpARM64MOVDloadidx8_0(v)
+ return rewriteValueARM64_OpARM64MOVDloadidx8(v)
case OpARM64MOVDreg:
- return rewriteValueARM64_OpARM64MOVDreg_0(v)
+ return rewriteValueARM64_OpARM64MOVDreg(v)
case OpARM64MOVDstore:
- return rewriteValueARM64_OpARM64MOVDstore_0(v)
+ return rewriteValueARM64_OpARM64MOVDstore(v)
case OpARM64MOVDstoreidx:
- return rewriteValueARM64_OpARM64MOVDstoreidx_0(v)
+ return rewriteValueARM64_OpARM64MOVDstoreidx(v)
case OpARM64MOVDstoreidx8:
- return rewriteValueARM64_OpARM64MOVDstoreidx8_0(v)
+ return rewriteValueARM64_OpARM64MOVDstoreidx8(v)
case OpARM64MOVDstorezero:
- return rewriteValueARM64_OpARM64MOVDstorezero_0(v)
+ return rewriteValueARM64_OpARM64MOVDstorezero(v)
case OpARM64MOVDstorezeroidx:
- return rewriteValueARM64_OpARM64MOVDstorezeroidx_0(v)
+ return rewriteValueARM64_OpARM64MOVDstorezeroidx(v)
case OpARM64MOVDstorezeroidx8:
- return rewriteValueARM64_OpARM64MOVDstorezeroidx8_0(v)
+ return rewriteValueARM64_OpARM64MOVDstorezeroidx8(v)
case OpARM64MOVHUload:
- return rewriteValueARM64_OpARM64MOVHUload_0(v)
+ return rewriteValueARM64_OpARM64MOVHUload(v)
case OpARM64MOVHUloadidx:
- return rewriteValueARM64_OpARM64MOVHUloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVHUloadidx(v)
case OpARM64MOVHUloadidx2:
- return rewriteValueARM64_OpARM64MOVHUloadidx2_0(v)
+ return rewriteValueARM64_OpARM64MOVHUloadidx2(v)
case OpARM64MOVHUreg:
- return rewriteValueARM64_OpARM64MOVHUreg_0(v) || rewriteValueARM64_OpARM64MOVHUreg_10(v)
+ return rewriteValueARM64_OpARM64MOVHUreg(v)
case OpARM64MOVHload:
- return rewriteValueARM64_OpARM64MOVHload_0(v)
+ return rewriteValueARM64_OpARM64MOVHload(v)
case OpARM64MOVHloadidx:
- return rewriteValueARM64_OpARM64MOVHloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVHloadidx(v)
case OpARM64MOVHloadidx2:
- return rewriteValueARM64_OpARM64MOVHloadidx2_0(v)
+ return rewriteValueARM64_OpARM64MOVHloadidx2(v)
case OpARM64MOVHreg:
- return rewriteValueARM64_OpARM64MOVHreg_0(v) || rewriteValueARM64_OpARM64MOVHreg_10(v)
+ return rewriteValueARM64_OpARM64MOVHreg(v)
case OpARM64MOVHstore:
- return rewriteValueARM64_OpARM64MOVHstore_0(v) || rewriteValueARM64_OpARM64MOVHstore_10(v) || rewriteValueARM64_OpARM64MOVHstore_20(v)
+ return rewriteValueARM64_OpARM64MOVHstore(v)
case OpARM64MOVHstoreidx:
- return rewriteValueARM64_OpARM64MOVHstoreidx_0(v) || rewriteValueARM64_OpARM64MOVHstoreidx_10(v)
+ return rewriteValueARM64_OpARM64MOVHstoreidx(v)
case OpARM64MOVHstoreidx2:
- return rewriteValueARM64_OpARM64MOVHstoreidx2_0(v)
+ return rewriteValueARM64_OpARM64MOVHstoreidx2(v)
case OpARM64MOVHstorezero:
- return rewriteValueARM64_OpARM64MOVHstorezero_0(v)
+ return rewriteValueARM64_OpARM64MOVHstorezero(v)
case OpARM64MOVHstorezeroidx:
- return rewriteValueARM64_OpARM64MOVHstorezeroidx_0(v)
+ return rewriteValueARM64_OpARM64MOVHstorezeroidx(v)
case OpARM64MOVHstorezeroidx2:
- return rewriteValueARM64_OpARM64MOVHstorezeroidx2_0(v)
+ return rewriteValueARM64_OpARM64MOVHstorezeroidx2(v)
case OpARM64MOVQstorezero:
- return rewriteValueARM64_OpARM64MOVQstorezero_0(v)
+ return rewriteValueARM64_OpARM64MOVQstorezero(v)
case OpARM64MOVWUload:
- return rewriteValueARM64_OpARM64MOVWUload_0(v)
+ return rewriteValueARM64_OpARM64MOVWUload(v)
case OpARM64MOVWUloadidx:
- return rewriteValueARM64_OpARM64MOVWUloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVWUloadidx(v)
case OpARM64MOVWUloadidx4:
- return rewriteValueARM64_OpARM64MOVWUloadidx4_0(v)
+ return rewriteValueARM64_OpARM64MOVWUloadidx4(v)
case OpARM64MOVWUreg:
- return rewriteValueARM64_OpARM64MOVWUreg_0(v) || rewriteValueARM64_OpARM64MOVWUreg_10(v)
+ return rewriteValueARM64_OpARM64MOVWUreg(v)
case OpARM64MOVWload:
- return rewriteValueARM64_OpARM64MOVWload_0(v)
+ return rewriteValueARM64_OpARM64MOVWload(v)
case OpARM64MOVWloadidx:
- return rewriteValueARM64_OpARM64MOVWloadidx_0(v)
+ return rewriteValueARM64_OpARM64MOVWloadidx(v)
case OpARM64MOVWloadidx4:
- return rewriteValueARM64_OpARM64MOVWloadidx4_0(v)
+ return rewriteValueARM64_OpARM64MOVWloadidx4(v)
case OpARM64MOVWreg:
- return rewriteValueARM64_OpARM64MOVWreg_0(v) || rewriteValueARM64_OpARM64MOVWreg_10(v)
+ return rewriteValueARM64_OpARM64MOVWreg(v)
case OpARM64MOVWstore:
- return rewriteValueARM64_OpARM64MOVWstore_0(v) || rewriteValueARM64_OpARM64MOVWstore_10(v)
+ return rewriteValueARM64_OpARM64MOVWstore(v)
case OpARM64MOVWstoreidx:
- return rewriteValueARM64_OpARM64MOVWstoreidx_0(v)
+ return rewriteValueARM64_OpARM64MOVWstoreidx(v)
case OpARM64MOVWstoreidx4:
- return rewriteValueARM64_OpARM64MOVWstoreidx4_0(v)
+ return rewriteValueARM64_OpARM64MOVWstoreidx4(v)
case OpARM64MOVWstorezero:
- return rewriteValueARM64_OpARM64MOVWstorezero_0(v)
+ return rewriteValueARM64_OpARM64MOVWstorezero(v)
case OpARM64MOVWstorezeroidx:
- return rewriteValueARM64_OpARM64MOVWstorezeroidx_0(v)
+ return rewriteValueARM64_OpARM64MOVWstorezeroidx(v)
case OpARM64MOVWstorezeroidx4:
- return rewriteValueARM64_OpARM64MOVWstorezeroidx4_0(v)
+ return rewriteValueARM64_OpARM64MOVWstorezeroidx4(v)
case OpARM64MSUB:
- return rewriteValueARM64_OpARM64MSUB_0(v) || rewriteValueARM64_OpARM64MSUB_10(v) || rewriteValueARM64_OpARM64MSUB_20(v)
+ return rewriteValueARM64_OpARM64MSUB(v)
case OpARM64MSUBW:
- return rewriteValueARM64_OpARM64MSUBW_0(v) || rewriteValueARM64_OpARM64MSUBW_10(v) || rewriteValueARM64_OpARM64MSUBW_20(v)
+ return rewriteValueARM64_OpARM64MSUBW(v)
case OpARM64MUL:
- return rewriteValueARM64_OpARM64MUL_0(v) || rewriteValueARM64_OpARM64MUL_10(v)
+ return rewriteValueARM64_OpARM64MUL(v)
case OpARM64MULW:
- return rewriteValueARM64_OpARM64MULW_0(v) || rewriteValueARM64_OpARM64MULW_10(v)
+ return rewriteValueARM64_OpARM64MULW(v)
case OpARM64MVN:
- return rewriteValueARM64_OpARM64MVN_0(v)
+ return rewriteValueARM64_OpARM64MVN(v)
case OpARM64MVNshiftLL:
- return rewriteValueARM64_OpARM64MVNshiftLL_0(v)
+ return rewriteValueARM64_OpARM64MVNshiftLL(v)
case OpARM64MVNshiftRA:
- return rewriteValueARM64_OpARM64MVNshiftRA_0(v)
+ return rewriteValueARM64_OpARM64MVNshiftRA(v)
case OpARM64MVNshiftRL:
- return rewriteValueARM64_OpARM64MVNshiftRL_0(v)
+ return rewriteValueARM64_OpARM64MVNshiftRL(v)
case OpARM64NEG:
- return rewriteValueARM64_OpARM64NEG_0(v)
+ return rewriteValueARM64_OpARM64NEG(v)
case OpARM64NEGshiftLL:
- return rewriteValueARM64_OpARM64NEGshiftLL_0(v)
+ return rewriteValueARM64_OpARM64NEGshiftLL(v)
case OpARM64NEGshiftRA:
- return rewriteValueARM64_OpARM64NEGshiftRA_0(v)
+ return rewriteValueARM64_OpARM64NEGshiftRA(v)
case OpARM64NEGshiftRL:
- return rewriteValueARM64_OpARM64NEGshiftRL_0(v)
+ return rewriteValueARM64_OpARM64NEGshiftRL(v)
case OpARM64NotEqual:
- return rewriteValueARM64_OpARM64NotEqual_0(v)
+ return rewriteValueARM64_OpARM64NotEqual(v)
case OpARM64OR:
- return rewriteValueARM64_OpARM64OR_0(v) || rewriteValueARM64_OpARM64OR_10(v) || rewriteValueARM64_OpARM64OR_20(v)
+ return rewriteValueARM64_OpARM64OR(v)
case OpARM64ORN:
- return rewriteValueARM64_OpARM64ORN_0(v)
+ return rewriteValueARM64_OpARM64ORN(v)
case OpARM64ORNshiftLL:
- return rewriteValueARM64_OpARM64ORNshiftLL_0(v)
+ return rewriteValueARM64_OpARM64ORNshiftLL(v)
case OpARM64ORNshiftRA:
- return rewriteValueARM64_OpARM64ORNshiftRA_0(v)
+ return rewriteValueARM64_OpARM64ORNshiftRA(v)
case OpARM64ORNshiftRL:
- return rewriteValueARM64_OpARM64ORNshiftRL_0(v)
+ return rewriteValueARM64_OpARM64ORNshiftRL(v)
case OpARM64ORconst:
- return rewriteValueARM64_OpARM64ORconst_0(v)
+ return rewriteValueARM64_OpARM64ORconst(v)
case OpARM64ORshiftLL:
- return rewriteValueARM64_OpARM64ORshiftLL_0(v) || rewriteValueARM64_OpARM64ORshiftLL_10(v) || rewriteValueARM64_OpARM64ORshiftLL_20(v)
+ return rewriteValueARM64_OpARM64ORshiftLL(v)
case OpARM64ORshiftRA:
- return rewriteValueARM64_OpARM64ORshiftRA_0(v)
+ return rewriteValueARM64_OpARM64ORshiftRA(v)
case OpARM64ORshiftRL:
- return rewriteValueARM64_OpARM64ORshiftRL_0(v)
+ return rewriteValueARM64_OpARM64ORshiftRL(v)
case OpARM64RORWconst:
- return rewriteValueARM64_OpARM64RORWconst_0(v)
+ return rewriteValueARM64_OpARM64RORWconst(v)
case OpARM64RORconst:
- return rewriteValueARM64_OpARM64RORconst_0(v)
+ return rewriteValueARM64_OpARM64RORconst(v)
case OpARM64SBCSflags:
- return rewriteValueARM64_OpARM64SBCSflags_0(v)
+ return rewriteValueARM64_OpARM64SBCSflags(v)
case OpARM64SLL:
- return rewriteValueARM64_OpARM64SLL_0(v)
+ return rewriteValueARM64_OpARM64SLL(v)
case OpARM64SLLconst:
- return rewriteValueARM64_OpARM64SLLconst_0(v)
+ return rewriteValueARM64_OpARM64SLLconst(v)
case OpARM64SRA:
- return rewriteValueARM64_OpARM64SRA_0(v)
+ return rewriteValueARM64_OpARM64SRA(v)
case OpARM64SRAconst:
- return rewriteValueARM64_OpARM64SRAconst_0(v)
+ return rewriteValueARM64_OpARM64SRAconst(v)
case OpARM64SRL:
- return rewriteValueARM64_OpARM64SRL_0(v)
+ return rewriteValueARM64_OpARM64SRL(v)
case OpARM64SRLconst:
- return rewriteValueARM64_OpARM64SRLconst_0(v) || rewriteValueARM64_OpARM64SRLconst_10(v)
+ return rewriteValueARM64_OpARM64SRLconst(v)
case OpARM64STP:
- return rewriteValueARM64_OpARM64STP_0(v)
+ return rewriteValueARM64_OpARM64STP(v)
case OpARM64SUB:
- return rewriteValueARM64_OpARM64SUB_0(v) || rewriteValueARM64_OpARM64SUB_10(v)
+ return rewriteValueARM64_OpARM64SUB(v)
case OpARM64SUBconst:
- return rewriteValueARM64_OpARM64SUBconst_0(v)
+ return rewriteValueARM64_OpARM64SUBconst(v)
case OpARM64SUBshiftLL:
- return rewriteValueARM64_OpARM64SUBshiftLL_0(v)
+ return rewriteValueARM64_OpARM64SUBshiftLL(v)
case OpARM64SUBshiftRA:
- return rewriteValueARM64_OpARM64SUBshiftRA_0(v)
+ return rewriteValueARM64_OpARM64SUBshiftRA(v)
case OpARM64SUBshiftRL:
- return rewriteValueARM64_OpARM64SUBshiftRL_0(v)
+ return rewriteValueARM64_OpARM64SUBshiftRL(v)
case OpARM64TST:
- return rewriteValueARM64_OpARM64TST_0(v)
+ return rewriteValueARM64_OpARM64TST(v)
case OpARM64TSTW:
- return rewriteValueARM64_OpARM64TSTW_0(v)
+ return rewriteValueARM64_OpARM64TSTW(v)
case OpARM64TSTWconst:
- return rewriteValueARM64_OpARM64TSTWconst_0(v)
+ return rewriteValueARM64_OpARM64TSTWconst(v)
case OpARM64TSTconst:
- return rewriteValueARM64_OpARM64TSTconst_0(v)
+ return rewriteValueARM64_OpARM64TSTconst(v)
case OpARM64TSTshiftLL:
- return rewriteValueARM64_OpARM64TSTshiftLL_0(v)
+ return rewriteValueARM64_OpARM64TSTshiftLL(v)
case OpARM64TSTshiftRA:
- return rewriteValueARM64_OpARM64TSTshiftRA_0(v)
+ return rewriteValueARM64_OpARM64TSTshiftRA(v)
case OpARM64TSTshiftRL:
- return rewriteValueARM64_OpARM64TSTshiftRL_0(v)
+ return rewriteValueARM64_OpARM64TSTshiftRL(v)
case OpARM64UBFIZ:
- return rewriteValueARM64_OpARM64UBFIZ_0(v)
+ return rewriteValueARM64_OpARM64UBFIZ(v)
case OpARM64UBFX:
- return rewriteValueARM64_OpARM64UBFX_0(v)
+ return rewriteValueARM64_OpARM64UBFX(v)
case OpARM64UDIV:
- return rewriteValueARM64_OpARM64UDIV_0(v)
+ return rewriteValueARM64_OpARM64UDIV(v)
case OpARM64UDIVW:
- return rewriteValueARM64_OpARM64UDIVW_0(v)
+ return rewriteValueARM64_OpARM64UDIVW(v)
case OpARM64UMOD:
- return rewriteValueARM64_OpARM64UMOD_0(v)
+ return rewriteValueARM64_OpARM64UMOD(v)
case OpARM64UMODW:
- return rewriteValueARM64_OpARM64UMODW_0(v)
+ return rewriteValueARM64_OpARM64UMODW(v)
case OpARM64XOR:
- return rewriteValueARM64_OpARM64XOR_0(v)
+ return rewriteValueARM64_OpARM64XOR(v)
case OpARM64XORconst:
- return rewriteValueARM64_OpARM64XORconst_0(v)
+ return rewriteValueARM64_OpARM64XORconst(v)
case OpARM64XORshiftLL:
- return rewriteValueARM64_OpARM64XORshiftLL_0(v)
+ return rewriteValueARM64_OpARM64XORshiftLL(v)
case OpARM64XORshiftRA:
- return rewriteValueARM64_OpARM64XORshiftRA_0(v)
+ return rewriteValueARM64_OpARM64XORshiftRA(v)
case OpARM64XORshiftRL:
- return rewriteValueARM64_OpARM64XORshiftRL_0(v)
+ return rewriteValueARM64_OpARM64XORshiftRL(v)
case OpAbs:
- return rewriteValueARM64_OpAbs_0(v)
+ return rewriteValueARM64_OpAbs(v)
case OpAdd16:
- return rewriteValueARM64_OpAdd16_0(v)
+ return rewriteValueARM64_OpAdd16(v)
case OpAdd32:
- return rewriteValueARM64_OpAdd32_0(v)
+ return rewriteValueARM64_OpAdd32(v)
case OpAdd32F:
- return rewriteValueARM64_OpAdd32F_0(v)
+ return rewriteValueARM64_OpAdd32F(v)
case OpAdd64:
- return rewriteValueARM64_OpAdd64_0(v)
+ return rewriteValueARM64_OpAdd64(v)
case OpAdd64F:
- return rewriteValueARM64_OpAdd64F_0(v)
+ return rewriteValueARM64_OpAdd64F(v)
case OpAdd8:
- return rewriteValueARM64_OpAdd8_0(v)
+ return rewriteValueARM64_OpAdd8(v)
case OpAddPtr:
- return rewriteValueARM64_OpAddPtr_0(v)
+ return rewriteValueARM64_OpAddPtr(v)
case OpAddr:
- return rewriteValueARM64_OpAddr_0(v)
+ return rewriteValueARM64_OpAddr(v)
case OpAnd16:
- return rewriteValueARM64_OpAnd16_0(v)
+ return rewriteValueARM64_OpAnd16(v)
case OpAnd32:
- return rewriteValueARM64_OpAnd32_0(v)
+ return rewriteValueARM64_OpAnd32(v)
case OpAnd64:
- return rewriteValueARM64_OpAnd64_0(v)
+ return rewriteValueARM64_OpAnd64(v)
case OpAnd8:
- return rewriteValueARM64_OpAnd8_0(v)
+ return rewriteValueARM64_OpAnd8(v)
case OpAndB:
- return rewriteValueARM64_OpAndB_0(v)
+ return rewriteValueARM64_OpAndB(v)
case OpAtomicAdd32:
- return rewriteValueARM64_OpAtomicAdd32_0(v)
+ return rewriteValueARM64_OpAtomicAdd32(v)
case OpAtomicAdd32Variant:
- return rewriteValueARM64_OpAtomicAdd32Variant_0(v)
+ return rewriteValueARM64_OpAtomicAdd32Variant(v)
case OpAtomicAdd64:
- return rewriteValueARM64_OpAtomicAdd64_0(v)
+ return rewriteValueARM64_OpAtomicAdd64(v)
case OpAtomicAdd64Variant:
- return rewriteValueARM64_OpAtomicAdd64Variant_0(v)
+ return rewriteValueARM64_OpAtomicAdd64Variant(v)
case OpAtomicAnd8:
- return rewriteValueARM64_OpAtomicAnd8_0(v)
+ return rewriteValueARM64_OpAtomicAnd8(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueARM64_OpAtomicCompareAndSwap32_0(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap32(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueARM64_OpAtomicCompareAndSwap64_0(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap64(v)
case OpAtomicExchange32:
- return rewriteValueARM64_OpAtomicExchange32_0(v)
+ return rewriteValueARM64_OpAtomicExchange32(v)
case OpAtomicExchange64:
- return rewriteValueARM64_OpAtomicExchange64_0(v)
+ return rewriteValueARM64_OpAtomicExchange64(v)
case OpAtomicLoad32:
- return rewriteValueARM64_OpAtomicLoad32_0(v)
+ return rewriteValueARM64_OpAtomicLoad32(v)
case OpAtomicLoad64:
- return rewriteValueARM64_OpAtomicLoad64_0(v)
+ return rewriteValueARM64_OpAtomicLoad64(v)
case OpAtomicLoad8:
- return rewriteValueARM64_OpAtomicLoad8_0(v)
+ return rewriteValueARM64_OpAtomicLoad8(v)
case OpAtomicLoadPtr:
- return rewriteValueARM64_OpAtomicLoadPtr_0(v)
+ return rewriteValueARM64_OpAtomicLoadPtr(v)
case OpAtomicOr8:
- return rewriteValueARM64_OpAtomicOr8_0(v)
+ return rewriteValueARM64_OpAtomicOr8(v)
case OpAtomicStore32:
- return rewriteValueARM64_OpAtomicStore32_0(v)
+ return rewriteValueARM64_OpAtomicStore32(v)
case OpAtomicStore64:
- return rewriteValueARM64_OpAtomicStore64_0(v)
+ return rewriteValueARM64_OpAtomicStore64(v)
case OpAtomicStore8:
- return rewriteValueARM64_OpAtomicStore8_0(v)
+ return rewriteValueARM64_OpAtomicStore8(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueARM64_OpAtomicStorePtrNoWB_0(v)
+ return rewriteValueARM64_OpAtomicStorePtrNoWB(v)
case OpAvg64u:
- return rewriteValueARM64_OpAvg64u_0(v)
+ return rewriteValueARM64_OpAvg64u(v)
case OpBitLen32:
- return rewriteValueARM64_OpBitLen32_0(v)
+ return rewriteValueARM64_OpBitLen32(v)
case OpBitLen64:
- return rewriteValueARM64_OpBitLen64_0(v)
+ return rewriteValueARM64_OpBitLen64(v)
case OpBitRev16:
- return rewriteValueARM64_OpBitRev16_0(v)
+ return rewriteValueARM64_OpBitRev16(v)
case OpBitRev32:
- return rewriteValueARM64_OpBitRev32_0(v)
+ return rewriteValueARM64_OpBitRev32(v)
case OpBitRev64:
- return rewriteValueARM64_OpBitRev64_0(v)
+ return rewriteValueARM64_OpBitRev64(v)
case OpBitRev8:
- return rewriteValueARM64_OpBitRev8_0(v)
+ return rewriteValueARM64_OpBitRev8(v)
case OpBswap32:
- return rewriteValueARM64_OpBswap32_0(v)
+ return rewriteValueARM64_OpBswap32(v)
case OpBswap64:
- return rewriteValueARM64_OpBswap64_0(v)
+ return rewriteValueARM64_OpBswap64(v)
case OpCeil:
- return rewriteValueARM64_OpCeil_0(v)
+ return rewriteValueARM64_OpCeil(v)
case OpClosureCall:
- return rewriteValueARM64_OpClosureCall_0(v)
+ return rewriteValueARM64_OpClosureCall(v)
case OpCom16:
- return rewriteValueARM64_OpCom16_0(v)
+ return rewriteValueARM64_OpCom16(v)
case OpCom32:
- return rewriteValueARM64_OpCom32_0(v)
+ return rewriteValueARM64_OpCom32(v)
case OpCom64:
- return rewriteValueARM64_OpCom64_0(v)
+ return rewriteValueARM64_OpCom64(v)
case OpCom8:
- return rewriteValueARM64_OpCom8_0(v)
+ return rewriteValueARM64_OpCom8(v)
case OpCondSelect:
- return rewriteValueARM64_OpCondSelect_0(v)
+ return rewriteValueARM64_OpCondSelect(v)
case OpConst16:
- return rewriteValueARM64_OpConst16_0(v)
+ return rewriteValueARM64_OpConst16(v)
case OpConst32:
- return rewriteValueARM64_OpConst32_0(v)
+ return rewriteValueARM64_OpConst32(v)
case OpConst32F:
- return rewriteValueARM64_OpConst32F_0(v)
+ return rewriteValueARM64_OpConst32F(v)
case OpConst64:
- return rewriteValueARM64_OpConst64_0(v)
+ return rewriteValueARM64_OpConst64(v)
case OpConst64F:
- return rewriteValueARM64_OpConst64F_0(v)
+ return rewriteValueARM64_OpConst64F(v)
case OpConst8:
- return rewriteValueARM64_OpConst8_0(v)
+ return rewriteValueARM64_OpConst8(v)
case OpConstBool:
- return rewriteValueARM64_OpConstBool_0(v)
+ return rewriteValueARM64_OpConstBool(v)
case OpConstNil:
- return rewriteValueARM64_OpConstNil_0(v)
+ return rewriteValueARM64_OpConstNil(v)
case OpCtz16:
- return rewriteValueARM64_OpCtz16_0(v)
+ return rewriteValueARM64_OpCtz16(v)
case OpCtz16NonZero:
- return rewriteValueARM64_OpCtz16NonZero_0(v)
+ return rewriteValueARM64_OpCtz16NonZero(v)
case OpCtz32:
- return rewriteValueARM64_OpCtz32_0(v)
+ return rewriteValueARM64_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueARM64_OpCtz32NonZero_0(v)
+ return rewriteValueARM64_OpCtz32NonZero(v)
case OpCtz64:
- return rewriteValueARM64_OpCtz64_0(v)
+ return rewriteValueARM64_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValueARM64_OpCtz64NonZero_0(v)
+ return rewriteValueARM64_OpCtz64NonZero(v)
case OpCtz8:
- return rewriteValueARM64_OpCtz8_0(v)
+ return rewriteValueARM64_OpCtz8(v)
case OpCtz8NonZero:
- return rewriteValueARM64_OpCtz8NonZero_0(v)
+ return rewriteValueARM64_OpCtz8NonZero(v)
case OpCvt32Fto32:
- return rewriteValueARM64_OpCvt32Fto32_0(v)
+ return rewriteValueARM64_OpCvt32Fto32(v)
case OpCvt32Fto32U:
- return rewriteValueARM64_OpCvt32Fto32U_0(v)
+ return rewriteValueARM64_OpCvt32Fto32U(v)
case OpCvt32Fto64:
- return rewriteValueARM64_OpCvt32Fto64_0(v)
+ return rewriteValueARM64_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValueARM64_OpCvt32Fto64F_0(v)
+ return rewriteValueARM64_OpCvt32Fto64F(v)
case OpCvt32Fto64U:
- return rewriteValueARM64_OpCvt32Fto64U_0(v)
+ return rewriteValueARM64_OpCvt32Fto64U(v)
case OpCvt32Uto32F:
- return rewriteValueARM64_OpCvt32Uto32F_0(v)
+ return rewriteValueARM64_OpCvt32Uto32F(v)
case OpCvt32Uto64F:
- return rewriteValueARM64_OpCvt32Uto64F_0(v)
+ return rewriteValueARM64_OpCvt32Uto64F(v)
case OpCvt32to32F:
- return rewriteValueARM64_OpCvt32to32F_0(v)
+ return rewriteValueARM64_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueARM64_OpCvt32to64F_0(v)
+ return rewriteValueARM64_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueARM64_OpCvt64Fto32_0(v)
+ return rewriteValueARM64_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueARM64_OpCvt64Fto32F_0(v)
+ return rewriteValueARM64_OpCvt64Fto32F(v)
case OpCvt64Fto32U:
- return rewriteValueARM64_OpCvt64Fto32U_0(v)
+ return rewriteValueARM64_OpCvt64Fto32U(v)
case OpCvt64Fto64:
- return rewriteValueARM64_OpCvt64Fto64_0(v)
+ return rewriteValueARM64_OpCvt64Fto64(v)
case OpCvt64Fto64U:
- return rewriteValueARM64_OpCvt64Fto64U_0(v)
+ return rewriteValueARM64_OpCvt64Fto64U(v)
case OpCvt64Uto32F:
- return rewriteValueARM64_OpCvt64Uto32F_0(v)
+ return rewriteValueARM64_OpCvt64Uto32F(v)
case OpCvt64Uto64F:
- return rewriteValueARM64_OpCvt64Uto64F_0(v)
+ return rewriteValueARM64_OpCvt64Uto64F(v)
case OpCvt64to32F:
- return rewriteValueARM64_OpCvt64to32F_0(v)
+ return rewriteValueARM64_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValueARM64_OpCvt64to64F_0(v)
+ return rewriteValueARM64_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValueARM64_OpDiv16_0(v)
+ return rewriteValueARM64_OpDiv16(v)
case OpDiv16u:
- return rewriteValueARM64_OpDiv16u_0(v)
+ return rewriteValueARM64_OpDiv16u(v)
case OpDiv32:
- return rewriteValueARM64_OpDiv32_0(v)
+ return rewriteValueARM64_OpDiv32(v)
case OpDiv32F:
- return rewriteValueARM64_OpDiv32F_0(v)
+ return rewriteValueARM64_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueARM64_OpDiv32u_0(v)
+ return rewriteValueARM64_OpDiv32u(v)
case OpDiv64:
- return rewriteValueARM64_OpDiv64_0(v)
+ return rewriteValueARM64_OpDiv64(v)
case OpDiv64F:
- return rewriteValueARM64_OpDiv64F_0(v)
+ return rewriteValueARM64_OpDiv64F(v)
case OpDiv64u:
- return rewriteValueARM64_OpDiv64u_0(v)
+ return rewriteValueARM64_OpDiv64u(v)
case OpDiv8:
- return rewriteValueARM64_OpDiv8_0(v)
+ return rewriteValueARM64_OpDiv8(v)
case OpDiv8u:
- return rewriteValueARM64_OpDiv8u_0(v)
+ return rewriteValueARM64_OpDiv8u(v)
case OpEq16:
- return rewriteValueARM64_OpEq16_0(v)
+ return rewriteValueARM64_OpEq16(v)
case OpEq32:
- return rewriteValueARM64_OpEq32_0(v)
+ return rewriteValueARM64_OpEq32(v)
case OpEq32F:
- return rewriteValueARM64_OpEq32F_0(v)
+ return rewriteValueARM64_OpEq32F(v)
case OpEq64:
- return rewriteValueARM64_OpEq64_0(v)
+ return rewriteValueARM64_OpEq64(v)
case OpEq64F:
- return rewriteValueARM64_OpEq64F_0(v)
+ return rewriteValueARM64_OpEq64F(v)
case OpEq8:
- return rewriteValueARM64_OpEq8_0(v)
+ return rewriteValueARM64_OpEq8(v)
case OpEqB:
- return rewriteValueARM64_OpEqB_0(v)
+ return rewriteValueARM64_OpEqB(v)
case OpEqPtr:
- return rewriteValueARM64_OpEqPtr_0(v)
+ return rewriteValueARM64_OpEqPtr(v)
case OpFMA:
- return rewriteValueARM64_OpFMA_0(v)
+ return rewriteValueARM64_OpFMA(v)
case OpFloor:
- return rewriteValueARM64_OpFloor_0(v)
+ return rewriteValueARM64_OpFloor(v)
case OpGeq16:
- return rewriteValueARM64_OpGeq16_0(v)
+ return rewriteValueARM64_OpGeq16(v)
case OpGeq16U:
- return rewriteValueARM64_OpGeq16U_0(v)
+ return rewriteValueARM64_OpGeq16U(v)
case OpGeq32:
- return rewriteValueARM64_OpGeq32_0(v)
+ return rewriteValueARM64_OpGeq32(v)
case OpGeq32F:
- return rewriteValueARM64_OpGeq32F_0(v)
+ return rewriteValueARM64_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueARM64_OpGeq32U_0(v)
+ return rewriteValueARM64_OpGeq32U(v)
case OpGeq64:
- return rewriteValueARM64_OpGeq64_0(v)
+ return rewriteValueARM64_OpGeq64(v)
case OpGeq64F:
- return rewriteValueARM64_OpGeq64F_0(v)
+ return rewriteValueARM64_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueARM64_OpGeq64U_0(v)
+ return rewriteValueARM64_OpGeq64U(v)
case OpGeq8:
- return rewriteValueARM64_OpGeq8_0(v)
+ return rewriteValueARM64_OpGeq8(v)
case OpGeq8U:
- return rewriteValueARM64_OpGeq8U_0(v)
+ return rewriteValueARM64_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueARM64_OpGetCallerPC_0(v)
+ return rewriteValueARM64_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueARM64_OpGetCallerSP_0(v)
+ return rewriteValueARM64_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueARM64_OpGetClosurePtr_0(v)
+ return rewriteValueARM64_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueARM64_OpGreater16_0(v)
+ return rewriteValueARM64_OpGreater16(v)
case OpGreater16U:
- return rewriteValueARM64_OpGreater16U_0(v)
+ return rewriteValueARM64_OpGreater16U(v)
case OpGreater32:
- return rewriteValueARM64_OpGreater32_0(v)
+ return rewriteValueARM64_OpGreater32(v)
case OpGreater32F:
- return rewriteValueARM64_OpGreater32F_0(v)
+ return rewriteValueARM64_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueARM64_OpGreater32U_0(v)
+ return rewriteValueARM64_OpGreater32U(v)
case OpGreater64:
- return rewriteValueARM64_OpGreater64_0(v)
+ return rewriteValueARM64_OpGreater64(v)
case OpGreater64F:
- return rewriteValueARM64_OpGreater64F_0(v)
+ return rewriteValueARM64_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueARM64_OpGreater64U_0(v)
+ return rewriteValueARM64_OpGreater64U(v)
case OpGreater8:
- return rewriteValueARM64_OpGreater8_0(v)
+ return rewriteValueARM64_OpGreater8(v)
case OpGreater8U:
- return rewriteValueARM64_OpGreater8U_0(v)
+ return rewriteValueARM64_OpGreater8U(v)
case OpHmul32:
- return rewriteValueARM64_OpHmul32_0(v)
+ return rewriteValueARM64_OpHmul32(v)
case OpHmul32u:
- return rewriteValueARM64_OpHmul32u_0(v)
+ return rewriteValueARM64_OpHmul32u(v)
case OpHmul64:
- return rewriteValueARM64_OpHmul64_0(v)
+ return rewriteValueARM64_OpHmul64(v)
case OpHmul64u:
- return rewriteValueARM64_OpHmul64u_0(v)
+ return rewriteValueARM64_OpHmul64u(v)
case OpInterCall:
- return rewriteValueARM64_OpInterCall_0(v)
+ return rewriteValueARM64_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueARM64_OpIsInBounds_0(v)
+ return rewriteValueARM64_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueARM64_OpIsNonNil_0(v)
+ return rewriteValueARM64_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueARM64_OpIsSliceInBounds_0(v)
+ return rewriteValueARM64_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueARM64_OpLeq16_0(v)
+ return rewriteValueARM64_OpLeq16(v)
case OpLeq16U:
- return rewriteValueARM64_OpLeq16U_0(v)
+ return rewriteValueARM64_OpLeq16U(v)
case OpLeq32:
- return rewriteValueARM64_OpLeq32_0(v)
+ return rewriteValueARM64_OpLeq32(v)
case OpLeq32F:
- return rewriteValueARM64_OpLeq32F_0(v)
+ return rewriteValueARM64_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueARM64_OpLeq32U_0(v)
+ return rewriteValueARM64_OpLeq32U(v)
case OpLeq64:
- return rewriteValueARM64_OpLeq64_0(v)
+ return rewriteValueARM64_OpLeq64(v)
case OpLeq64F:
- return rewriteValueARM64_OpLeq64F_0(v)
+ return rewriteValueARM64_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueARM64_OpLeq64U_0(v)
+ return rewriteValueARM64_OpLeq64U(v)
case OpLeq8:
- return rewriteValueARM64_OpLeq8_0(v)
+ return rewriteValueARM64_OpLeq8(v)
case OpLeq8U:
- return rewriteValueARM64_OpLeq8U_0(v)
+ return rewriteValueARM64_OpLeq8U(v)
case OpLess16:
- return rewriteValueARM64_OpLess16_0(v)
+ return rewriteValueARM64_OpLess16(v)
case OpLess16U:
- return rewriteValueARM64_OpLess16U_0(v)
+ return rewriteValueARM64_OpLess16U(v)
case OpLess32:
- return rewriteValueARM64_OpLess32_0(v)
+ return rewriteValueARM64_OpLess32(v)
case OpLess32F:
- return rewriteValueARM64_OpLess32F_0(v)
+ return rewriteValueARM64_OpLess32F(v)
case OpLess32U:
- return rewriteValueARM64_OpLess32U_0(v)
+ return rewriteValueARM64_OpLess32U(v)
case OpLess64:
- return rewriteValueARM64_OpLess64_0(v)
+ return rewriteValueARM64_OpLess64(v)
case OpLess64F:
- return rewriteValueARM64_OpLess64F_0(v)
+ return rewriteValueARM64_OpLess64F(v)
case OpLess64U:
- return rewriteValueARM64_OpLess64U_0(v)
+ return rewriteValueARM64_OpLess64U(v)
case OpLess8:
- return rewriteValueARM64_OpLess8_0(v)
+ return rewriteValueARM64_OpLess8(v)
case OpLess8U:
- return rewriteValueARM64_OpLess8U_0(v)
+ return rewriteValueARM64_OpLess8U(v)
case OpLoad:
- return rewriteValueARM64_OpLoad_0(v)
+ return rewriteValueARM64_OpLoad(v)
case OpLocalAddr:
- return rewriteValueARM64_OpLocalAddr_0(v)
+ return rewriteValueARM64_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueARM64_OpLsh16x16_0(v)
+ return rewriteValueARM64_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueARM64_OpLsh16x32_0(v)
+ return rewriteValueARM64_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueARM64_OpLsh16x64_0(v)
+ return rewriteValueARM64_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueARM64_OpLsh16x8_0(v)
+ return rewriteValueARM64_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueARM64_OpLsh32x16_0(v)
+ return rewriteValueARM64_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueARM64_OpLsh32x32_0(v)
+ return rewriteValueARM64_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueARM64_OpLsh32x64_0(v)
+ return rewriteValueARM64_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueARM64_OpLsh32x8_0(v)
+ return rewriteValueARM64_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueARM64_OpLsh64x16_0(v)
+ return rewriteValueARM64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueARM64_OpLsh64x32_0(v)
+ return rewriteValueARM64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueARM64_OpLsh64x64_0(v)
+ return rewriteValueARM64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueARM64_OpLsh64x8_0(v)
+ return rewriteValueARM64_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueARM64_OpLsh8x16_0(v)
+ return rewriteValueARM64_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueARM64_OpLsh8x32_0(v)
+ return rewriteValueARM64_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueARM64_OpLsh8x64_0(v)
+ return rewriteValueARM64_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueARM64_OpLsh8x8_0(v)
+ return rewriteValueARM64_OpLsh8x8(v)
case OpMod16:
- return rewriteValueARM64_OpMod16_0(v)
+ return rewriteValueARM64_OpMod16(v)
case OpMod16u:
- return rewriteValueARM64_OpMod16u_0(v)
+ return rewriteValueARM64_OpMod16u(v)
case OpMod32:
- return rewriteValueARM64_OpMod32_0(v)
+ return rewriteValueARM64_OpMod32(v)
case OpMod32u:
- return rewriteValueARM64_OpMod32u_0(v)
+ return rewriteValueARM64_OpMod32u(v)
case OpMod64:
- return rewriteValueARM64_OpMod64_0(v)
+ return rewriteValueARM64_OpMod64(v)
case OpMod64u:
- return rewriteValueARM64_OpMod64u_0(v)
+ return rewriteValueARM64_OpMod64u(v)
case OpMod8:
- return rewriteValueARM64_OpMod8_0(v)
+ return rewriteValueARM64_OpMod8(v)
case OpMod8u:
- return rewriteValueARM64_OpMod8u_0(v)
+ return rewriteValueARM64_OpMod8u(v)
case OpMove:
- return rewriteValueARM64_OpMove_0(v) || rewriteValueARM64_OpMove_10(v)
+ return rewriteValueARM64_OpMove(v)
case OpMul16:
- return rewriteValueARM64_OpMul16_0(v)
+ return rewriteValueARM64_OpMul16(v)
case OpMul32:
- return rewriteValueARM64_OpMul32_0(v)
+ return rewriteValueARM64_OpMul32(v)
case OpMul32F:
- return rewriteValueARM64_OpMul32F_0(v)
+ return rewriteValueARM64_OpMul32F(v)
case OpMul64:
- return rewriteValueARM64_OpMul64_0(v)
+ return rewriteValueARM64_OpMul64(v)
case OpMul64F:
- return rewriteValueARM64_OpMul64F_0(v)
+ return rewriteValueARM64_OpMul64F(v)
case OpMul64uhilo:
- return rewriteValueARM64_OpMul64uhilo_0(v)
+ return rewriteValueARM64_OpMul64uhilo(v)
case OpMul8:
- return rewriteValueARM64_OpMul8_0(v)
+ return rewriteValueARM64_OpMul8(v)
case OpNeg16:
- return rewriteValueARM64_OpNeg16_0(v)
+ return rewriteValueARM64_OpNeg16(v)
case OpNeg32:
- return rewriteValueARM64_OpNeg32_0(v)
+ return rewriteValueARM64_OpNeg32(v)
case OpNeg32F:
- return rewriteValueARM64_OpNeg32F_0(v)
+ return rewriteValueARM64_OpNeg32F(v)
case OpNeg64:
- return rewriteValueARM64_OpNeg64_0(v)
+ return rewriteValueARM64_OpNeg64(v)
case OpNeg64F:
- return rewriteValueARM64_OpNeg64F_0(v)
+ return rewriteValueARM64_OpNeg64F(v)
case OpNeg8:
- return rewriteValueARM64_OpNeg8_0(v)
+ return rewriteValueARM64_OpNeg8(v)
case OpNeq16:
- return rewriteValueARM64_OpNeq16_0(v)
+ return rewriteValueARM64_OpNeq16(v)
case OpNeq32:
- return rewriteValueARM64_OpNeq32_0(v)
+ return rewriteValueARM64_OpNeq32(v)
case OpNeq32F:
- return rewriteValueARM64_OpNeq32F_0(v)
+ return rewriteValueARM64_OpNeq32F(v)
case OpNeq64:
- return rewriteValueARM64_OpNeq64_0(v)
+ return rewriteValueARM64_OpNeq64(v)
case OpNeq64F:
- return rewriteValueARM64_OpNeq64F_0(v)
+ return rewriteValueARM64_OpNeq64F(v)
case OpNeq8:
- return rewriteValueARM64_OpNeq8_0(v)
+ return rewriteValueARM64_OpNeq8(v)
case OpNeqB:
- return rewriteValueARM64_OpNeqB_0(v)
+ return rewriteValueARM64_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueARM64_OpNeqPtr_0(v)
+ return rewriteValueARM64_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueARM64_OpNilCheck_0(v)
+ return rewriteValueARM64_OpNilCheck(v)
case OpNot:
- return rewriteValueARM64_OpNot_0(v)
+ return rewriteValueARM64_OpNot(v)
case OpOffPtr:
- return rewriteValueARM64_OpOffPtr_0(v)
+ return rewriteValueARM64_OpOffPtr(v)
case OpOr16:
- return rewriteValueARM64_OpOr16_0(v)
+ return rewriteValueARM64_OpOr16(v)
case OpOr32:
- return rewriteValueARM64_OpOr32_0(v)
+ return rewriteValueARM64_OpOr32(v)
case OpOr64:
- return rewriteValueARM64_OpOr64_0(v)
+ return rewriteValueARM64_OpOr64(v)
case OpOr8:
- return rewriteValueARM64_OpOr8_0(v)
+ return rewriteValueARM64_OpOr8(v)
case OpOrB:
- return rewriteValueARM64_OpOrB_0(v)
+ return rewriteValueARM64_OpOrB(v)
case OpPanicBounds:
- return rewriteValueARM64_OpPanicBounds_0(v)
+ return rewriteValueARM64_OpPanicBounds(v)
case OpPopCount16:
- return rewriteValueARM64_OpPopCount16_0(v)
+ return rewriteValueARM64_OpPopCount16(v)
case OpPopCount32:
- return rewriteValueARM64_OpPopCount32_0(v)
+ return rewriteValueARM64_OpPopCount32(v)
case OpPopCount64:
- return rewriteValueARM64_OpPopCount64_0(v)
+ return rewriteValueARM64_OpPopCount64(v)
case OpRotateLeft16:
- return rewriteValueARM64_OpRotateLeft16_0(v)
+ return rewriteValueARM64_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueARM64_OpRotateLeft32_0(v)
+ return rewriteValueARM64_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueARM64_OpRotateLeft64_0(v)
+ return rewriteValueARM64_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueARM64_OpRotateLeft8_0(v)
+ return rewriteValueARM64_OpRotateLeft8(v)
case OpRound:
- return rewriteValueARM64_OpRound_0(v)
+ return rewriteValueARM64_OpRound(v)
case OpRound32F:
- return rewriteValueARM64_OpRound32F_0(v)
+ return rewriteValueARM64_OpRound32F(v)
case OpRound64F:
- return rewriteValueARM64_OpRound64F_0(v)
+ return rewriteValueARM64_OpRound64F(v)
case OpRoundToEven:
- return rewriteValueARM64_OpRoundToEven_0(v)
+ return rewriteValueARM64_OpRoundToEven(v)
case OpRsh16Ux16:
- return rewriteValueARM64_OpRsh16Ux16_0(v)
+ return rewriteValueARM64_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueARM64_OpRsh16Ux32_0(v)
+ return rewriteValueARM64_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueARM64_OpRsh16Ux64_0(v)
+ return rewriteValueARM64_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueARM64_OpRsh16Ux8_0(v)
+ return rewriteValueARM64_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueARM64_OpRsh16x16_0(v)
+ return rewriteValueARM64_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueARM64_OpRsh16x32_0(v)
+ return rewriteValueARM64_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueARM64_OpRsh16x64_0(v)
+ return rewriteValueARM64_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueARM64_OpRsh16x8_0(v)
+ return rewriteValueARM64_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueARM64_OpRsh32Ux16_0(v)
+ return rewriteValueARM64_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueARM64_OpRsh32Ux32_0(v)
+ return rewriteValueARM64_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueARM64_OpRsh32Ux64_0(v)
+ return rewriteValueARM64_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueARM64_OpRsh32Ux8_0(v)
+ return rewriteValueARM64_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueARM64_OpRsh32x16_0(v)
+ return rewriteValueARM64_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueARM64_OpRsh32x32_0(v)
+ return rewriteValueARM64_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueARM64_OpRsh32x64_0(v)
+ return rewriteValueARM64_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueARM64_OpRsh32x8_0(v)
+ return rewriteValueARM64_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueARM64_OpRsh64Ux16_0(v)
+ return rewriteValueARM64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueARM64_OpRsh64Ux32_0(v)
+ return rewriteValueARM64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueARM64_OpRsh64Ux64_0(v)
+ return rewriteValueARM64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueARM64_OpRsh64Ux8_0(v)
+ return rewriteValueARM64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueARM64_OpRsh64x16_0(v)
+ return rewriteValueARM64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueARM64_OpRsh64x32_0(v)
+ return rewriteValueARM64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueARM64_OpRsh64x64_0(v)
+ return rewriteValueARM64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueARM64_OpRsh64x8_0(v)
+ return rewriteValueARM64_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueARM64_OpRsh8Ux16_0(v)
+ return rewriteValueARM64_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueARM64_OpRsh8Ux32_0(v)
+ return rewriteValueARM64_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueARM64_OpRsh8Ux64_0(v)
+ return rewriteValueARM64_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueARM64_OpRsh8Ux8_0(v)
+ return rewriteValueARM64_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueARM64_OpRsh8x16_0(v)
+ return rewriteValueARM64_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueARM64_OpRsh8x32_0(v)
+ return rewriteValueARM64_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueARM64_OpRsh8x64_0(v)
+ return rewriteValueARM64_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueARM64_OpRsh8x8_0(v)
+ return rewriteValueARM64_OpRsh8x8(v)
case OpSelect0:
- return rewriteValueARM64_OpSelect0_0(v)
+ return rewriteValueARM64_OpSelect0(v)
case OpSelect1:
- return rewriteValueARM64_OpSelect1_0(v)
+ return rewriteValueARM64_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueARM64_OpSignExt16to32_0(v)
+ return rewriteValueARM64_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValueARM64_OpSignExt16to64_0(v)
+ return rewriteValueARM64_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValueARM64_OpSignExt32to64_0(v)
+ return rewriteValueARM64_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValueARM64_OpSignExt8to16_0(v)
+ return rewriteValueARM64_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueARM64_OpSignExt8to32_0(v)
+ return rewriteValueARM64_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValueARM64_OpSignExt8to64_0(v)
+ return rewriteValueARM64_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValueARM64_OpSlicemask_0(v)
+ return rewriteValueARM64_OpSlicemask(v)
case OpSqrt:
- return rewriteValueARM64_OpSqrt_0(v)
+ return rewriteValueARM64_OpSqrt(v)
case OpStaticCall:
- return rewriteValueARM64_OpStaticCall_0(v)
+ return rewriteValueARM64_OpStaticCall(v)
case OpStore:
- return rewriteValueARM64_OpStore_0(v)
+ return rewriteValueARM64_OpStore(v)
case OpSub16:
- return rewriteValueARM64_OpSub16_0(v)
+ return rewriteValueARM64_OpSub16(v)
case OpSub32:
- return rewriteValueARM64_OpSub32_0(v)
+ return rewriteValueARM64_OpSub32(v)
case OpSub32F:
- return rewriteValueARM64_OpSub32F_0(v)
+ return rewriteValueARM64_OpSub32F(v)
case OpSub64:
- return rewriteValueARM64_OpSub64_0(v)
+ return rewriteValueARM64_OpSub64(v)
case OpSub64F:
- return rewriteValueARM64_OpSub64F_0(v)
+ return rewriteValueARM64_OpSub64F(v)
case OpSub8:
- return rewriteValueARM64_OpSub8_0(v)
+ return rewriteValueARM64_OpSub8(v)
case OpSubPtr:
- return rewriteValueARM64_OpSubPtr_0(v)
+ return rewriteValueARM64_OpSubPtr(v)
case OpTrunc:
- return rewriteValueARM64_OpTrunc_0(v)
+ return rewriteValueARM64_OpTrunc(v)
case OpTrunc16to8:
- return rewriteValueARM64_OpTrunc16to8_0(v)
+ return rewriteValueARM64_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueARM64_OpTrunc32to16_0(v)
+ return rewriteValueARM64_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueARM64_OpTrunc32to8_0(v)
+ return rewriteValueARM64_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValueARM64_OpTrunc64to16_0(v)
+ return rewriteValueARM64_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValueARM64_OpTrunc64to32_0(v)
+ return rewriteValueARM64_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValueARM64_OpTrunc64to8_0(v)
+ return rewriteValueARM64_OpTrunc64to8(v)
case OpWB:
- return rewriteValueARM64_OpWB_0(v)
+ return rewriteValueARM64_OpWB(v)
case OpXor16:
- return rewriteValueARM64_OpXor16_0(v)
+ return rewriteValueARM64_OpXor16(v)
case OpXor32:
- return rewriteValueARM64_OpXor32_0(v)
+ return rewriteValueARM64_OpXor32(v)
case OpXor64:
- return rewriteValueARM64_OpXor64_0(v)
+ return rewriteValueARM64_OpXor64(v)
case OpXor8:
- return rewriteValueARM64_OpXor8_0(v)
+ return rewriteValueARM64_OpXor8(v)
case OpZero:
- return rewriteValueARM64_OpZero_0(v) || rewriteValueARM64_OpZero_10(v) || rewriteValueARM64_OpZero_20(v)
+ return rewriteValueARM64_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueARM64_OpZeroExt16to32_0(v)
+ return rewriteValueARM64_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValueARM64_OpZeroExt16to64_0(v)
+ return rewriteValueARM64_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValueARM64_OpZeroExt32to64_0(v)
+ return rewriteValueARM64_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValueARM64_OpZeroExt8to16_0(v)
+ return rewriteValueARM64_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueARM64_OpZeroExt8to32_0(v)
+ return rewriteValueARM64_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValueARM64_OpZeroExt8to64_0(v)
+ return rewriteValueARM64_OpZeroExt8to64(v)
}
return false
}
-func rewriteValueARM64_OpARM64ADCSflags_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADCSflags(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1008,7 +1008,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1277,13 +1277,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64ADD_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ADD (SRL <typ.UInt64> x (ANDconst <t> [63] y)) (CSEL0 <typ.UInt64> {cc} (SLL x (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y))) (CMPconst [64] (SUB <t> (MOVDconst [64]) (ANDconst <t> [63] y)))))
// cond: cc.(Op) == OpARM64LessThanU
// result: (ROR x y)
@@ -1500,7 +1493,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr))
// result: (MOVDaddr [off1+off2] {sym} ptr)
@@ -1572,7 +1565,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1695,7 +1688,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1732,7 +1725,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1803,7 +1796,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64AND_0(v *Value) bool {
+func rewriteValueARM64_OpARM64AND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVDconst [c]))
@@ -1921,7 +1914,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVDconst [0])
@@ -2048,7 +2041,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2104,7 +2097,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2160,7 +2153,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2216,7 +2209,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BIC_0(v *Value) bool {
+func rewriteValueARM64_OpARM64BIC(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BIC x (MOVDconst [c]))
@@ -2305,7 +2298,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftLL x (MOVDconst [c]) [d])
@@ -2341,7 +2334,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRA x (MOVDconst [c]) [d])
@@ -2377,7 +2370,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (BICshiftRL x (MOVDconst [c]) [d])
@@ -2413,7 +2406,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMN_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMN(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMN x (MOVDconst [c]))
@@ -2503,7 +2496,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMNW x (MOVDconst [c]))
@@ -2524,7 +2517,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNWconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMNWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(-y)
@@ -2603,7 +2596,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMNconst (MOVDconst [x]) [y])
// cond: int64(x)==int64(-y)
@@ -2682,7 +2675,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2719,7 +2712,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2756,7 +2749,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMNshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMNshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2793,7 +2786,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMP_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMP(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2953,7 +2946,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2987,7 +2980,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -3088,7 +3081,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
@@ -3230,7 +3223,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3269,7 +3262,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3308,7 +3301,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3347,7 +3340,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSEL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CSEL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3472,7 +3465,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64CSEL0_0(v *Value) bool {
+func rewriteValueARM64_OpARM64CSEL0(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CSEL0 {cc} x (InvertFlags cmp))
@@ -3558,7 +3551,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIV_0(v *Value) bool {
+func rewriteValueARM64_OpARM64DIV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIV (MOVDconst [c]) (MOVDconst [d]))
@@ -3578,7 +3571,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (DIVW (MOVDconst [c]) (MOVDconst [d]))
@@ -3598,7 +3591,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EON_0(v *Value) bool {
+func rewriteValueARM64_OpARM64EON(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EON x (MOVDconst [c]))
@@ -3687,7 +3680,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64EONshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftLL x (MOVDconst [c]) [d])
@@ -3723,7 +3716,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64EONshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftRA x (MOVDconst [c]) [d])
@@ -3759,7 +3752,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64EONshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64EONshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EONshiftRL x (MOVDconst [c]) [d])
@@ -3795,7 +3788,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64Equal_0(v *Value) bool {
+func rewriteValueARM64_OpARM64Equal(v *Value) bool {
v_0 := v.Args[0]
// match: (Equal (FlagEQ))
// result: (MOVDconst [1])
@@ -3860,7 +3853,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FADDD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FADDD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDD a (FMULD x y))
@@ -3901,7 +3894,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FADDS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FADDS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS a (FMULS x y))
@@ -3942,7 +3935,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCMPD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FCMPD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3972,7 +3965,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FCMPS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FCMPS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4002,7 +3995,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDfpgp_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDfpgp(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (FMOVDfpgp <t> (Arg [off] {sym}))
@@ -4024,7 +4017,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDgpfp_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDgpfp(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (FMOVDgpfp <t> (Arg [off] {sym}))
@@ -4046,7 +4039,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4137,7 +4130,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4173,7 +4166,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4272,7 +4265,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -4313,7 +4306,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4404,7 +4397,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4440,7 +4433,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4539,7 +4532,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -4580,7 +4573,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMULD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMULD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMULD (FNEGD x) y)
@@ -4601,7 +4594,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FMULS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FMULS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMULS (FNEGS x) y)
@@ -4622,7 +4615,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNEGD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FNEGD(v *Value) bool {
v_0 := v.Args[0]
// match: (FNEGD (FMULD x y))
// result: (FNMULD x y)
@@ -4652,7 +4645,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNEGS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FNEGS(v *Value) bool {
v_0 := v.Args[0]
// match: (FNEGS (FMULS x y))
// result: (FNMULS x y)
@@ -4682,7 +4675,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNMULD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FNMULD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FNMULD (FNEGD x) y)
@@ -4703,7 +4696,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FNMULS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FNMULS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FNMULS (FNEGS x) y)
@@ -4724,7 +4717,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FSUBD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FSUBD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBD a (FMULD x y))
@@ -4789,7 +4782,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64FSUBS_0(v *Value) bool {
+func rewriteValueARM64_OpARM64FSUBS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS a (FMULS x y))
@@ -4854,7 +4847,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqual (FlagEQ))
// result: (MOVDconst [1])
@@ -4919,7 +4912,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualF_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqualF(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualF (InvertFlags x))
// result: (LessEqualF x)
@@ -4934,7 +4927,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterEqualU (FlagEQ))
// result: (MOVDconst [1])
@@ -4999,7 +4992,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterThan (FlagEQ))
// result: (MOVDconst [0])
@@ -5064,7 +5057,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanF_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThanF(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanF (InvertFlags x))
// result: (LessThanF x)
@@ -5079,7 +5072,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
v_0 := v.Args[0]
// match: (GreaterThanU (FlagEQ))
// result: (MOVDconst [0])
@@ -5144,7 +5137,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (LessEqual (FlagEQ))
// result: (MOVDconst [1])
@@ -5209,7 +5202,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualF_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqualF(v *Value) bool {
v_0 := v.Args[0]
// match: (LessEqualF (InvertFlags x))
// result: (GreaterEqualF x)
@@ -5224,7 +5217,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
v_0 := v.Args[0]
// match: (LessEqualU (FlagEQ))
// result: (MOVDconst [1])
@@ -5289,7 +5282,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
v_0 := v.Args[0]
// match: (LessThan (FlagEQ))
// result: (MOVDconst [0])
@@ -5354,7 +5347,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanF_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThanF(v *Value) bool {
v_0 := v.Args[0]
// match: (LessThanF (InvertFlags x))
// result: (GreaterThanF x)
@@ -5369,7 +5362,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThanU(v *Value) bool {
v_0 := v.Args[0]
// match: (LessThanU (FlagEQ))
// result: (MOVDconst [0])
@@ -5434,7 +5427,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MADD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MADD(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5632,13 +5625,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MADD_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MADD a (MOVDconst [-1]) x)
// result: (SUB a x)
for {
@@ -5832,13 +5818,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MADD_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MADD (MOVDconst [c]) x y)
// result: (ADDconst [c] (MUL <x.Type> x y))
for {
@@ -5875,7 +5854,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MADDW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MADDW(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6088,13 +6067,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MADDW_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MADDW a (MOVDconst [c]) x)
// cond: int32(c)==-1
// result: (SUB a x)
@@ -6303,13 +6275,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MADDW_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MADDW (MOVDconst [c]) x y)
// result: (ADDconst [c] (MULW <x.Type> x y))
for {
@@ -6346,7 +6311,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MNEG_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MNEG(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6564,11 +6529,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MNEG_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MNEG (MOVDconst [c]) (MOVDconst [d]))
// result: (MOVDconst [-c*d])
for {
@@ -6589,7 +6549,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MNEGW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MNEGW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6822,11 +6782,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MNEGW_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MNEGW (MOVDconst [c]) (MOVDconst [d]))
// result: (MOVDconst [-int64(int32(c)*int32(d))])
for {
@@ -6847,7 +6802,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOD (MOVDconst [c]) (MOVDconst [d]))
@@ -6867,7 +6822,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MODW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MODW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MODW (MOVDconst [c]) (MOVDconst [d]))
@@ -6887,7 +6842,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6994,7 +6949,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7049,7 +7004,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(MOVBUload _ _))
// result: (MOVDreg x)
@@ -7158,7 +7113,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7252,7 +7207,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7307,7 +7262,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -7374,7 +7329,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7583,12 +7538,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVBstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVBstore [i] {s} ptr0 (SRLconst [8] w) x:(MOVBstore [i-1] {s} ptr1 w mem))
// cond: x.Uses == 1 && isSamePtr(ptr0, ptr1) && clobber(x)
// result: (MOVHstore [i-1] {s} ptr0 w mem)
@@ -7941,13 +7890,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVBstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVBstore [i] {s} ptr0 (UBFX [bfc] w) x:(MOVBstore [i-1] {s} ptr1 w0:(UBFX [bfc2] w) mem))
// cond: x.Uses == 1 && isSamePtr(ptr0, ptr1) && getARM64BFwidth(bfc) == 32 - getARM64BFlsb(bfc) && getARM64BFwidth(bfc2) == 32 - getARM64BFlsb(bfc2) && getARM64BFlsb(bfc2) == getARM64BFlsb(bfc) - 8 && clobber(x)
// result: (MOVHstore [i-1] {s} ptr0 w0 mem)
@@ -8587,13 +8529,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVBstore_30(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVBstore [i] {s} ptr w x0:(MOVBstore [i-1] {s} ptr (SRLconst [8] w) x1:(MOVBstore [i-2] {s} ptr (SRLconst [16] w) x2:(MOVBstore [i-3] {s} ptr (SRLconst [24] w) mem))))
// cond: x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && clobber(x0) && clobber(x1) && clobber(x2)
// result: (MOVWstore [i-3] {s} ptr (REVW <w.Type> w) mem)
@@ -9001,11 +8936,12 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
// match: (MOVBstoreidx ptr (MOVDconst [c]) val mem)
// result: (MOVBstore [c] ptr val mem)
for {
@@ -9185,14 +9121,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVBstoreidx_10(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVBstoreidx ptr (ADDconst [3] idx) w x0:(MOVBstoreidx ptr (ADDconst [2] idx) (UBFX [armBFAuxInt(8, 24)] w) x1:(MOVBstoreidx ptr (ADDconst [1] idx) (UBFX [armBFAuxInt(16, 16)] w) x2:(MOVBstoreidx ptr idx (UBFX [armBFAuxInt(24, 8)] w) mem))))
// cond: x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && clobber(x0) && clobber(x1) && clobber(x2)
// result: (MOVWstoreidx ptr idx (REVW <w.Type> w) mem)
@@ -9381,7 +9309,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9516,7 +9444,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstorezeroidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstorezeroidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9575,7 +9503,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9721,7 +9649,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9806,7 +9734,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDloadidx8_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDloadidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9846,7 +9774,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVDreg x)
// cond: x.Uses == 1
@@ -9873,7 +9801,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10012,7 +9940,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10102,7 +10030,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstoreidx8_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstoreidx8(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10141,7 +10069,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10330,7 +10258,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstorezeroidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezeroidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10396,7 +10324,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstorezeroidx8_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezeroidx8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10417,7 +10345,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10545,7 +10473,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10651,7 +10579,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUloadidx2_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUloadidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10691,7 +10619,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x:(MOVBUload _ _))
// result: (MOVDreg x)
@@ -10816,10 +10744,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVHUreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVHUreg (SRLconst [sc] x))
// cond: isARM64BFMask(sc, 1<<16-1, 0)
// result: (UBFX [armBFAuxInt(sc, 16)] x)
@@ -10839,7 +10763,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10954,7 +10878,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11060,7 +10984,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHloadidx2_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHloadidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11100,7 +11024,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -11219,10 +11143,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVHreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVHreg (MOVDconst [c]))
// result: (MOVDconst [int64(int16(c))])
for {
@@ -11253,7 +11173,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11475,13 +11395,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVHstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVHstore [2] {s} (ADD ptr0 idx0) (SRLconst [16] w) x:(MOVHstoreidx ptr1 idx1 w mem))
// cond: x.Uses == 1 && s == nil && (isSamePtr(ptr0, ptr1) && isSamePtr(idx0, idx1) || isSamePtr(ptr0, idx1) && isSamePtr(idx0, ptr1)) && clobber(x)
// result: (MOVWstoreidx ptr1 idx1 w mem)
@@ -11853,13 +11766,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVHstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVHstore [2] {s} (ADDshiftLL [1] ptr0 idx0) (SRLconst [j] w) x:(MOVHstoreidx2 ptr1 idx1 w0:(SRLconst [j-16] w) mem))
// cond: x.Uses == 1 && s == nil && isSamePtr(ptr0, ptr1) && isSamePtr(idx0, idx1) && clobber(x)
// result: (MOVWstoreidx ptr1 (SLLconst <idx1.Type> [1] idx1) w0 mem)
@@ -11901,7 +11807,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12080,13 +11986,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVHstoreidx_10(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (MOVHstoreidx ptr idx (MOVWUreg x) mem)
// result: (MOVHstoreidx ptr idx x mem)
for {
@@ -12134,7 +12033,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstoreidx2_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstoreidx2(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12241,7 +12140,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12429,7 +12328,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstorezeroidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezeroidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12554,7 +12453,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstorezeroidx2_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezeroidx2(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12575,7 +12474,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVQstorezero_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVQstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12627,7 +12526,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12773,7 +12672,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12858,7 +12757,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUloadidx4_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12898,7 +12797,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg x:(MOVBUload _ _))
// result: (MOVDreg x)
@@ -13018,10 +12917,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVWUreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVWUreg x:(MOVWUreg _))
// result: (MOVDreg x)
for {
@@ -13093,7 +12988,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13208,7 +13103,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWloadidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13293,7 +13188,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWloadidx4_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWloadidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13333,7 +13228,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x:(MOVBload _ _))
// result: (MOVDreg x)
@@ -13455,10 +13350,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVWreg x:(MOVHloadidx2 _ _ _))
// result: (MOVDreg x)
for {
@@ -13569,7 +13460,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13812,13 +13703,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MOVWstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVWstore [4] {s} (ADDshiftLL [2] ptr0 idx0) (SRLconst [32] w) x:(MOVWstoreidx4 ptr1 idx1 w mem))
// cond: x.Uses == 1 && s == nil && isSamePtr(ptr0, ptr1) && isSamePtr(idx0, idx1) && clobber(x)
// result: (MOVDstoreidx ptr1 (SLLconst <idx1.Type> [2] idx1) w mem)
@@ -13969,7 +13853,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstoreidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -14121,7 +14005,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstoreidx4_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstoreidx4(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -14194,7 +14078,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14382,7 +14266,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstorezeroidx_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezeroidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14471,7 +14355,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstorezeroidx4_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezeroidx4(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14492,7 +14376,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MSUB_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MSUB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14690,13 +14574,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MSUB_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MSUB a (MOVDconst [-1]) x)
// result: (ADD a x)
for {
@@ -14890,13 +14767,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MSUB_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MSUB (MOVDconst [c]) x y)
// result: (ADDconst [c] (MNEG <x.Type> x y))
for {
@@ -14933,7 +14803,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MSUBW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MSUBW(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15146,13 +15016,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MSUBW_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MSUBW a (MOVDconst [c]) x)
// cond: int32(c)==-1
// result: (ADD a x)
@@ -15361,13 +15224,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64MSUBW_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MSUBW (MOVDconst [c]) x y)
// result: (ADDconst [c] (MNEGW <x.Type> x y))
for {
@@ -15404,7 +15260,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MUL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MUL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15604,12 +15460,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MUL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MUL x (MOVDconst [c]))
// cond: c%9 == 0 && isPowerOfTwo(c/9)
// result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3]))
@@ -15654,7 +15504,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MULW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MULW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15869,12 +15719,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64MULW_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (MULW x (MOVDconst [c]))
// cond: c%9 == 0 && isPowerOfTwo(c/9) && is32Bit(c)
// result: (SLLconst [log2(c/9)] (ADDshiftLL <x.Type> x x [3]))
@@ -15919,7 +15763,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVN_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MVN(v *Value) bool {
v_0 := v.Args[0]
// match: (MVN (MOVDconst [c]))
// result: (MOVDconst [^c])
@@ -15988,7 +15832,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MVNshiftLL(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftLL (MOVDconst [c]) [d])
// result: (MOVDconst [^int64(uint64(c)<<uint64(d))])
@@ -16004,7 +15848,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MVNshiftRA(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRA (MOVDconst [c]) [d])
// result: (MOVDconst [^(c>>uint64(d))])
@@ -16020,7 +15864,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64MVNshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64MVNshiftRL(v *Value) bool {
v_0 := v.Args[0]
// match: (MVNshiftRL (MOVDconst [c]) [d])
// result: (MOVDconst [^int64(uint64(c)>>uint64(d))])
@@ -16036,7 +15880,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEG_0(v *Value) bool {
+func rewriteValueARM64_OpARM64NEG(v *Value) bool {
v_0 := v.Args[0]
// match: (NEG (MUL x y))
// result: (MNEG x y)
@@ -16131,7 +15975,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64NEGshiftLL(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftLL (MOVDconst [c]) [d])
// result: (MOVDconst [-int64(uint64(c)<<uint64(d))])
@@ -16147,7 +15991,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64NEGshiftRA(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftRA (MOVDconst [c]) [d])
// result: (MOVDconst [-(c>>uint64(d))])
@@ -16163,7 +16007,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NEGshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64NEGshiftRL(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGshiftRL (MOVDconst [c]) [d])
// result: (MOVDconst [-int64(uint64(c)>>uint64(d))])
@@ -16179,7 +16023,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool {
+func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
v_0 := v.Args[0]
// match: (NotEqual (FlagEQ))
// result: (MOVDconst [0])
@@ -16244,7 +16088,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64OR_0(v *Value) bool {
+func rewriteValueARM64_OpARM64OR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16647,12 +16491,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64OR_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (OR (UBFIZ [bfc] x) (ANDconst [ac] y))
// cond: ac == ^((1<<uint(getARM64BFwidth(bfc))-1) << uint(getARM64BFlsb(bfc)))
// result: (BFI [bfc] y x)
@@ -17680,12 +17518,6 @@
}
break
}
- return false
-}
-func rewriteValueARM64_OpARM64OR_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (OR <t> o0:(ORshiftLL [8] o1:(ORshiftLL [16] s0:(SLLconst [24] y0:(MOVDnop x0:(MOVBUloadidx ptr idx mem))) y1:(MOVDnop x1:(MOVBUloadidx ptr (ADDconst [1] idx) mem))) y2:(MOVDnop x2:(MOVBUloadidx ptr (ADDconst [2] idx) mem))) y3:(MOVDnop x3:(MOVBUloadidx ptr (ADDconst [3] idx) mem)))
// cond: 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) (REVW <t> (MOVWUloadidx <t> ptr idx mem))
@@ -18297,7 +18129,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORN_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORN(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x (MOVDconst [c]))
@@ -18386,7 +18218,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORNshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftLL x (MOVDconst [c]) [d])
@@ -18422,7 +18254,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORNshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftRA x (MOVDconst [c]) [d])
@@ -18458,7 +18290,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORNshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORNshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORNshiftRL x (MOVDconst [c]) [d])
@@ -18494,7 +18326,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -18564,7 +18396,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18775,12 +18607,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (ORshiftLL <t> [8] y0:(MOVDnop x0:(MOVBUloadidx ptr0 idx0 mem)) y1:(MOVDnop x1:(MOVBUload [1] {s} p1:(ADD ptr1 idx1) mem)))
// cond: s == nil && x0.Uses == 1 && x1.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && mergePoint(b,x0,x1) != nil && (isSamePtr(ptr0, ptr1) && isSamePtr(idx0, idx1) || isSamePtr(ptr0, idx1) && isSamePtr(idx0, ptr1)) && clobber(x0) && clobber(x1) && clobber(y0) && clobber(y1)
// result: @mergePoint(b,x0,x1) (MOVHUloadidx <t> ptr0 idx0 mem)
@@ -19544,12 +19370,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64ORshiftLL_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (ORshiftLL <t> [8] y0:(MOVDnop x0:(MOVBUload [i1] {s} p mem)) y1:(MOVDnop x1:(MOVBUload [i0] {s} p mem)))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(y0) && clobber(y1)
// result: @mergePoint(b,x0,x1) (REV16W <t> (MOVHUload <t> [i0] {s} p mem))
@@ -20241,7 +20061,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20297,7 +20117,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20435,7 +20255,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64RORWconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64RORWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (RORWconst [c] (RORWconst [d] x))
// result: (RORWconst [(c+d)&31] x)
@@ -20453,7 +20273,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64RORconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64RORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (RORconst [c] (RORconst [d] x))
// result: (RORconst [(c+d)&63] x)
@@ -20471,7 +20291,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SBCSflags_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SBCSflags(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20527,7 +20347,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL x (MOVDconst [c]))
@@ -20545,7 +20365,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SLLconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVDconst [d]))
// result: (MOVDconst [d<<uint64(c)])
@@ -20665,7 +20485,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVDconst [c]))
@@ -20683,7 +20503,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRAconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVDconst [d]))
// result: (MOVDconst [d>>uint64(c)])
@@ -20822,7 +20642,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL x (MOVDconst [c]))
@@ -20840,7 +20660,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVDconst [d]))
// result: (MOVDconst [int64(uint64(d)>>uint64(c))])
@@ -21012,10 +20832,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64SRLconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (SRLconst [sc] (UBFIZ [bfc] x))
// cond: sc < getARM64BFlsb(bfc)
// result: (UBFIZ [armBFAuxInt(getARM64BFlsb(bfc)-sc, getARM64BFwidth(bfc))] x)
@@ -21054,7 +20870,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64STP_0(v *Value) bool {
+func rewriteValueARM64_OpARM64STP(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -21133,7 +20949,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUB_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21315,11 +21131,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValueARM64_OpARM64SUB_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (SUB x0 x1:(SRAconst [c] y))
// cond: clobberIfDead(x1)
// result: (SUBshiftRA x0 y [c])
@@ -21342,7 +21153,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -21398,7 +21209,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftLL x (MOVDconst [c]) [d])
@@ -21434,7 +21245,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftRA x (MOVDconst [c]) [d])
@@ -21470,7 +21281,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBshiftRL x (MOVDconst [c]) [d])
@@ -21506,7 +21317,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TST_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TST(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TST x (MOVDconst [c]))
@@ -21596,7 +21407,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (TSTW x (MOVDconst [c]))
@@ -21617,7 +21428,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTWconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TSTWconst (MOVDconst [x]) [y])
// cond: int32(x&y)==0
@@ -21666,7 +21477,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTconst(v *Value) bool {
v_0 := v.Args[0]
// match: (TSTconst (MOVDconst [x]) [y])
// cond: int64(x&y)==0
@@ -21715,7 +21526,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21752,7 +21563,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21789,7 +21600,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64TSTshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64TSTshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21826,7 +21637,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UBFIZ_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UBFIZ(v *Value) bool {
v_0 := v.Args[0]
// match: (UBFIZ [bfc] (SLLconst [sc] x))
// cond: sc < getARM64BFwidth(bfc)
@@ -21848,7 +21659,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UBFX_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UBFX(v *Value) bool {
v_0 := v.Args[0]
// match: (UBFX [bfc] (SRLconst [sc] x))
// cond: sc+getARM64BFwidth(bfc)+getARM64BFlsb(bfc) < 64
@@ -21924,7 +21735,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (UDIV x (MOVDconst [1]))
@@ -21973,7 +21784,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (UDIVW x (MOVDconst [c]))
@@ -22027,7 +21838,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22094,7 +21905,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool {
+func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22166,7 +21977,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XOR_0(v *Value) bool {
+func rewriteValueARM64_OpARM64XOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22570,7 +22381,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool {
+func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -22623,7 +22434,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22763,7 +22574,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22817,7 +22628,7 @@
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22905,7 +22716,7 @@
}
return false
}
-func rewriteValueARM64_OpAbs_0(v *Value) bool {
+func rewriteValueARM64_OpAbs(v *Value) bool {
v_0 := v.Args[0]
// match: (Abs x)
// result: (FABSD x)
@@ -22916,7 +22727,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd16_0(v *Value) bool {
+func rewriteValueARM64_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -22930,7 +22741,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd32_0(v *Value) bool {
+func rewriteValueARM64_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -22944,7 +22755,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd32F_0(v *Value) bool {
+func rewriteValueARM64_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -22958,7 +22769,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd64_0(v *Value) bool {
+func rewriteValueARM64_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -22972,7 +22783,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd64F_0(v *Value) bool {
+func rewriteValueARM64_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -22986,7 +22797,7 @@
return true
}
}
-func rewriteValueARM64_OpAdd8_0(v *Value) bool {
+func rewriteValueARM64_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -23000,7 +22811,7 @@
return true
}
}
-func rewriteValueARM64_OpAddPtr_0(v *Value) bool {
+func rewriteValueARM64_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -23014,7 +22825,7 @@
return true
}
}
-func rewriteValueARM64_OpAddr_0(v *Value) bool {
+func rewriteValueARM64_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} base)
@@ -23027,7 +22838,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd16_0(v *Value) bool {
+func rewriteValueARM64_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -23041,7 +22852,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd32_0(v *Value) bool {
+func rewriteValueARM64_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -23055,7 +22866,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd64_0(v *Value) bool {
+func rewriteValueARM64_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -23069,7 +22880,7 @@
return true
}
}
-func rewriteValueARM64_OpAnd8_0(v *Value) bool {
+func rewriteValueARM64_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -23083,7 +22894,7 @@
return true
}
}
-func rewriteValueARM64_OpAndB_0(v *Value) bool {
+func rewriteValueARM64_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -23097,7 +22908,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23114,7 +22925,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd32Variant_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd32Variant(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23131,7 +22942,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23148,7 +22959,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAdd64Variant_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd64Variant(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23165,7 +22976,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicAnd8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23186,7 +22997,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -23206,7 +23017,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -23226,7 +23037,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23243,7 +23054,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23260,7 +23071,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -23274,7 +23085,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -23288,7 +23099,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -23302,7 +23113,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -23316,7 +23127,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicOr8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23337,7 +23148,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23354,7 +23165,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23371,7 +23182,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23388,7 +23199,7 @@
return true
}
}
-func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23405,7 +23216,7 @@
return true
}
}
-func rewriteValueARM64_OpAvg64u_0(v *Value) bool {
+func rewriteValueARM64_OpAvg64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23427,7 +23238,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen32_0(v *Value) bool {
+func rewriteValueARM64_OpBitLen32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23445,7 +23256,7 @@
return true
}
}
-func rewriteValueARM64_OpBitLen64_0(v *Value) bool {
+func rewriteValueARM64_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23463,7 +23274,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev16_0(v *Value) bool {
+func rewriteValueARM64_OpBitRev16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23479,7 +23290,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev32_0(v *Value) bool {
+func rewriteValueARM64_OpBitRev32(v *Value) bool {
v_0 := v.Args[0]
// match: (BitRev32 x)
// result: (RBITW x)
@@ -23490,7 +23301,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev64_0(v *Value) bool {
+func rewriteValueARM64_OpBitRev64(v *Value) bool {
v_0 := v.Args[0]
// match: (BitRev64 x)
// result: (RBIT x)
@@ -23501,7 +23312,7 @@
return true
}
}
-func rewriteValueARM64_OpBitRev8_0(v *Value) bool {
+func rewriteValueARM64_OpBitRev8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23517,7 +23328,7 @@
return true
}
}
-func rewriteValueARM64_OpBswap32_0(v *Value) bool {
+func rewriteValueARM64_OpBswap32(v *Value) bool {
v_0 := v.Args[0]
// match: (Bswap32 x)
// result: (REVW x)
@@ -23528,7 +23339,7 @@
return true
}
}
-func rewriteValueARM64_OpBswap64_0(v *Value) bool {
+func rewriteValueARM64_OpBswap64(v *Value) bool {
v_0 := v.Args[0]
// match: (Bswap64 x)
// result: (REV x)
@@ -23539,7 +23350,7 @@
return true
}
}
-func rewriteValueARM64_OpCeil_0(v *Value) bool {
+func rewriteValueARM64_OpCeil(v *Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (FRINTPD x)
@@ -23550,7 +23361,7 @@
return true
}
}
-func rewriteValueARM64_OpClosureCall_0(v *Value) bool {
+func rewriteValueARM64_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23569,7 +23380,7 @@
return true
}
}
-func rewriteValueARM64_OpCom16_0(v *Value) bool {
+func rewriteValueARM64_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (MVN x)
@@ -23580,7 +23391,7 @@
return true
}
}
-func rewriteValueARM64_OpCom32_0(v *Value) bool {
+func rewriteValueARM64_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (MVN x)
@@ -23591,7 +23402,7 @@
return true
}
}
-func rewriteValueARM64_OpCom64_0(v *Value) bool {
+func rewriteValueARM64_OpCom64(v *Value) bool {
v_0 := v.Args[0]
// match: (Com64 x)
// result: (MVN x)
@@ -23602,7 +23413,7 @@
return true
}
}
-func rewriteValueARM64_OpCom8_0(v *Value) bool {
+func rewriteValueARM64_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (MVN x)
@@ -23613,7 +23424,7 @@
return true
}
}
-func rewriteValueARM64_OpCondSelect_0(v *Value) bool {
+func rewriteValueARM64_OpCondSelect(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -23657,7 +23468,7 @@
}
return false
}
-func rewriteValueARM64_OpConst16_0(v *Value) bool {
+func rewriteValueARM64_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [val])
for {
@@ -23667,7 +23478,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32_0(v *Value) bool {
+func rewriteValueARM64_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [val])
for {
@@ -23677,7 +23488,7 @@
return true
}
}
-func rewriteValueARM64_OpConst32F_0(v *Value) bool {
+func rewriteValueARM64_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (FMOVSconst [val])
for {
@@ -23687,7 +23498,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64_0(v *Value) bool {
+func rewriteValueARM64_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [val])
for {
@@ -23697,7 +23508,7 @@
return true
}
}
-func rewriteValueARM64_OpConst64F_0(v *Value) bool {
+func rewriteValueARM64_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (FMOVDconst [val])
for {
@@ -23707,7 +23518,7 @@
return true
}
}
-func rewriteValueARM64_OpConst8_0(v *Value) bool {
+func rewriteValueARM64_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [val])
for {
@@ -23717,7 +23528,7 @@
return true
}
}
-func rewriteValueARM64_OpConstBool_0(v *Value) bool {
+func rewriteValueARM64_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVDconst [b])
for {
@@ -23727,7 +23538,7 @@
return true
}
}
-func rewriteValueARM64_OpConstNil_0(v *Value) bool {
+func rewriteValueARM64_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -23736,7 +23547,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz16_0(v *Value) bool {
+func rewriteValueARM64_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23756,7 +23567,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz16NonZero_0(v *Value) bool {
+func rewriteValueARM64_OpCtz16NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz16NonZero x)
// result: (Ctz32 x)
@@ -23767,7 +23578,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz32_0(v *Value) bool {
+func rewriteValueARM64_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz32 <t> x)
@@ -23782,7 +23593,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueARM64_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (Ctz32 x)
@@ -23793,7 +23604,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz64_0(v *Value) bool {
+func rewriteValueARM64_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Ctz64 <t> x)
@@ -23808,7 +23619,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValueARM64_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64NonZero x)
// result: (Ctz64 x)
@@ -23819,7 +23630,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz8_0(v *Value) bool {
+func rewriteValueARM64_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -23839,7 +23650,7 @@
return true
}
}
-func rewriteValueARM64_OpCtz8NonZero_0(v *Value) bool {
+func rewriteValueARM64_OpCtz8NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz8NonZero x)
// result: (Ctz32 x)
@@ -23850,7 +23661,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (FCVTZSSW x)
@@ -23861,7 +23672,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32U x)
// result: (FCVTZUSW x)
@@ -23872,7 +23683,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 x)
// result: (FCVTZSS x)
@@ -23883,7 +23694,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (FCVTSD x)
@@ -23894,7 +23705,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64U x)
// result: (FCVTZUS x)
@@ -23905,7 +23716,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Uto32F x)
// result: (UCVTFWS x)
@@ -23916,7 +23727,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Uto64F x)
// result: (UCVTFWD x)
@@ -23927,7 +23738,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (SCVTFWS x)
@@ -23938,7 +23749,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (SCVTFWD x)
@@ -23949,7 +23760,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (FCVTZSDW x)
@@ -23960,7 +23771,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (FCVTDS x)
@@ -23971,7 +23782,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32U x)
// result: (FCVTZUDW x)
@@ -23982,7 +23793,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 x)
// result: (FCVTZSD x)
@@ -23993,7 +23804,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64U x)
// result: (FCVTZUD x)
@@ -24004,7 +23815,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Uto32F x)
// result: (UCVTFS x)
@@ -24015,7 +23826,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Uto64F x)
// result: (UCVTFD x)
@@ -24026,7 +23837,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F x)
// result: (SCVTFS x)
@@ -24037,7 +23848,7 @@
return true
}
}
-func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool {
+func rewriteValueARM64_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F x)
// result: (SCVTFD x)
@@ -24048,7 +23859,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv16_0(v *Value) bool {
+func rewriteValueARM64_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24068,7 +23879,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv16u_0(v *Value) bool {
+func rewriteValueARM64_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24088,7 +23899,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32_0(v *Value) bool {
+func rewriteValueARM64_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 x y)
@@ -24102,7 +23913,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32F_0(v *Value) bool {
+func rewriteValueARM64_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -24116,7 +23927,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv32u_0(v *Value) bool {
+func rewriteValueARM64_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32u x y)
@@ -24130,7 +23941,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64_0(v *Value) bool {
+func rewriteValueARM64_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -24144,7 +23955,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64F_0(v *Value) bool {
+func rewriteValueARM64_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -24158,7 +23969,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv64u_0(v *Value) bool {
+func rewriteValueARM64_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64u x y)
@@ -24172,7 +23983,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv8_0(v *Value) bool {
+func rewriteValueARM64_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24192,7 +24003,7 @@
return true
}
}
-func rewriteValueARM64_OpDiv8u_0(v *Value) bool {
+func rewriteValueARM64_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24212,7 +24023,7 @@
return true
}
}
-func rewriteValueARM64_OpEq16_0(v *Value) bool {
+func rewriteValueARM64_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24234,7 +24045,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32_0(v *Value) bool {
+func rewriteValueARM64_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24251,7 +24062,7 @@
return true
}
}
-func rewriteValueARM64_OpEq32F_0(v *Value) bool {
+func rewriteValueARM64_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24268,7 +24079,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64_0(v *Value) bool {
+func rewriteValueARM64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24285,7 +24096,7 @@
return true
}
}
-func rewriteValueARM64_OpEq64F_0(v *Value) bool {
+func rewriteValueARM64_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24302,7 +24113,7 @@
return true
}
}
-func rewriteValueARM64_OpEq8_0(v *Value) bool {
+func rewriteValueARM64_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24324,7 +24135,7 @@
return true
}
}
-func rewriteValueARM64_OpEqB_0(v *Value) bool {
+func rewriteValueARM64_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24345,7 +24156,7 @@
return true
}
}
-func rewriteValueARM64_OpEqPtr_0(v *Value) bool {
+func rewriteValueARM64_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24362,7 +24173,7 @@
return true
}
}
-func rewriteValueARM64_OpFMA_0(v *Value) bool {
+func rewriteValueARM64_OpFMA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -24379,7 +24190,7 @@
return true
}
}
-func rewriteValueARM64_OpFloor_0(v *Value) bool {
+func rewriteValueARM64_OpFloor(v *Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (FRINTMD x)
@@ -24390,7 +24201,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq16_0(v *Value) bool {
+func rewriteValueARM64_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24412,7 +24223,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq16U_0(v *Value) bool {
+func rewriteValueARM64_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24434,7 +24245,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32_0(v *Value) bool {
+func rewriteValueARM64_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24451,7 +24262,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32F_0(v *Value) bool {
+func rewriteValueARM64_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24468,7 +24279,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq32U_0(v *Value) bool {
+func rewriteValueARM64_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24485,7 +24296,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64_0(v *Value) bool {
+func rewriteValueARM64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24502,7 +24313,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64F_0(v *Value) bool {
+func rewriteValueARM64_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24519,7 +24330,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq64U_0(v *Value) bool {
+func rewriteValueARM64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24536,7 +24347,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq8_0(v *Value) bool {
+func rewriteValueARM64_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24558,7 +24369,7 @@
return true
}
}
-func rewriteValueARM64_OpGeq8U_0(v *Value) bool {
+func rewriteValueARM64_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24580,7 +24391,7 @@
return true
}
}
-func rewriteValueARM64_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueARM64_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -24588,7 +24399,7 @@
return true
}
}
-func rewriteValueARM64_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueARM64_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -24596,7 +24407,7 @@
return true
}
}
-func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueARM64_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -24604,7 +24415,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater16_0(v *Value) bool {
+func rewriteValueARM64_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24626,7 +24437,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater16U_0(v *Value) bool {
+func rewriteValueARM64_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24648,7 +24459,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32_0(v *Value) bool {
+func rewriteValueARM64_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24665,7 +24476,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32F_0(v *Value) bool {
+func rewriteValueARM64_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24682,7 +24493,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater32U_0(v *Value) bool {
+func rewriteValueARM64_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24699,7 +24510,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64_0(v *Value) bool {
+func rewriteValueARM64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24716,7 +24527,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64F_0(v *Value) bool {
+func rewriteValueARM64_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24733,7 +24544,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater64U_0(v *Value) bool {
+func rewriteValueARM64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24750,7 +24561,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater8_0(v *Value) bool {
+func rewriteValueARM64_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24772,7 +24583,7 @@
return true
}
}
-func rewriteValueARM64_OpGreater8U_0(v *Value) bool {
+func rewriteValueARM64_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24794,7 +24605,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32_0(v *Value) bool {
+func rewriteValueARM64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24813,7 +24624,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul32u_0(v *Value) bool {
+func rewriteValueARM64_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24832,7 +24643,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul64_0(v *Value) bool {
+func rewriteValueARM64_OpHmul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64 x y)
@@ -24846,7 +24657,7 @@
return true
}
}
-func rewriteValueARM64_OpHmul64u_0(v *Value) bool {
+func rewriteValueARM64_OpHmul64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64u x y)
@@ -24860,7 +24671,7 @@
return true
}
}
-func rewriteValueARM64_OpInterCall_0(v *Value) bool {
+func rewriteValueARM64_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -24876,7 +24687,7 @@
return true
}
}
-func rewriteValueARM64_OpIsInBounds_0(v *Value) bool {
+func rewriteValueARM64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24893,7 +24704,7 @@
return true
}
}
-func rewriteValueARM64_OpIsNonNil_0(v *Value) bool {
+func rewriteValueARM64_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -24908,7 +24719,7 @@
return true
}
}
-func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24925,7 +24736,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16_0(v *Value) bool {
+func rewriteValueARM64_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24947,7 +24758,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq16U_0(v *Value) bool {
+func rewriteValueARM64_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24969,7 +24780,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32_0(v *Value) bool {
+func rewriteValueARM64_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -24986,7 +24797,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32F_0(v *Value) bool {
+func rewriteValueARM64_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25003,7 +24814,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq32U_0(v *Value) bool {
+func rewriteValueARM64_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25020,7 +24831,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64_0(v *Value) bool {
+func rewriteValueARM64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25037,7 +24848,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64F_0(v *Value) bool {
+func rewriteValueARM64_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25054,7 +24865,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq64U_0(v *Value) bool {
+func rewriteValueARM64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25071,7 +24882,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8_0(v *Value) bool {
+func rewriteValueARM64_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25093,7 +24904,7 @@
return true
}
}
-func rewriteValueARM64_OpLeq8U_0(v *Value) bool {
+func rewriteValueARM64_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25115,7 +24926,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16_0(v *Value) bool {
+func rewriteValueARM64_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25137,7 +24948,7 @@
return true
}
}
-func rewriteValueARM64_OpLess16U_0(v *Value) bool {
+func rewriteValueARM64_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25159,7 +24970,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32_0(v *Value) bool {
+func rewriteValueARM64_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25176,7 +24987,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32F_0(v *Value) bool {
+func rewriteValueARM64_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25193,7 +25004,7 @@
return true
}
}
-func rewriteValueARM64_OpLess32U_0(v *Value) bool {
+func rewriteValueARM64_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25210,7 +25021,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64_0(v *Value) bool {
+func rewriteValueARM64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25227,7 +25038,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64F_0(v *Value) bool {
+func rewriteValueARM64_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25244,7 +25055,7 @@
return true
}
}
-func rewriteValueARM64_OpLess64U_0(v *Value) bool {
+func rewriteValueARM64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25261,7 +25072,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8_0(v *Value) bool {
+func rewriteValueARM64_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25283,7 +25094,7 @@
return true
}
}
-func rewriteValueARM64_OpLess8U_0(v *Value) bool {
+func rewriteValueARM64_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25305,7 +25116,7 @@
return true
}
}
-func rewriteValueARM64_OpLoad_0(v *Value) bool {
+func rewriteValueARM64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -25460,7 +25271,7 @@
}
return false
}
-func rewriteValueARM64_OpLocalAddr_0(v *Value) bool {
+func rewriteValueARM64_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVDaddr {sym} base)
@@ -25473,7 +25284,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x16_0(v *Value) bool {
+func rewriteValueARM64_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25504,7 +25315,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x32_0(v *Value) bool {
+func rewriteValueARM64_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25535,7 +25346,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x64_0(v *Value) bool {
+func rewriteValueARM64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25561,7 +25372,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh16x8_0(v *Value) bool {
+func rewriteValueARM64_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25592,7 +25403,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x16_0(v *Value) bool {
+func rewriteValueARM64_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25623,7 +25434,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x32_0(v *Value) bool {
+func rewriteValueARM64_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25654,7 +25465,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x64_0(v *Value) bool {
+func rewriteValueARM64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25680,7 +25491,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh32x8_0(v *Value) bool {
+func rewriteValueARM64_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25711,7 +25522,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x16_0(v *Value) bool {
+func rewriteValueARM64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25742,7 +25553,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x32_0(v *Value) bool {
+func rewriteValueARM64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25773,7 +25584,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x64_0(v *Value) bool {
+func rewriteValueARM64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25799,7 +25610,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh64x8_0(v *Value) bool {
+func rewriteValueARM64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25830,7 +25641,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x16_0(v *Value) bool {
+func rewriteValueARM64_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25861,7 +25672,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x32_0(v *Value) bool {
+func rewriteValueARM64_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25892,7 +25703,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x64_0(v *Value) bool {
+func rewriteValueARM64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25918,7 +25729,7 @@
return true
}
}
-func rewriteValueARM64_OpLsh8x8_0(v *Value) bool {
+func rewriteValueARM64_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25949,7 +25760,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16_0(v *Value) bool {
+func rewriteValueARM64_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25969,7 +25780,7 @@
return true
}
}
-func rewriteValueARM64_OpMod16u_0(v *Value) bool {
+func rewriteValueARM64_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -25989,7 +25800,7 @@
return true
}
}
-func rewriteValueARM64_OpMod32_0(v *Value) bool {
+func rewriteValueARM64_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32 x y)
@@ -26003,7 +25814,7 @@
return true
}
}
-func rewriteValueARM64_OpMod32u_0(v *Value) bool {
+func rewriteValueARM64_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32u x y)
@@ -26017,7 +25828,7 @@
return true
}
}
-func rewriteValueARM64_OpMod64_0(v *Value) bool {
+func rewriteValueARM64_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -26031,7 +25842,7 @@
return true
}
}
-func rewriteValueARM64_OpMod64u_0(v *Value) bool {
+func rewriteValueARM64_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64u x y)
@@ -26045,7 +25856,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8_0(v *Value) bool {
+func rewriteValueARM64_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26065,7 +25876,7 @@
return true
}
}
-func rewriteValueARM64_OpMod8u_0(v *Value) bool {
+func rewriteValueARM64_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26085,11 +25896,12 @@
return true
}
}
-func rewriteValueARM64_OpMove_0(v *Value) bool {
+func rewriteValueARM64_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Move [0] _ _ mem)
// result: mem
@@ -26319,15 +26131,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueARM64_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Move [16] dst src mem)
// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
for {
@@ -26488,7 +26291,7 @@
}
return false
}
-func rewriteValueARM64_OpMul16_0(v *Value) bool {
+func rewriteValueARM64_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -26502,7 +26305,7 @@
return true
}
}
-func rewriteValueARM64_OpMul32_0(v *Value) bool {
+func rewriteValueARM64_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -26516,7 +26319,7 @@
return true
}
}
-func rewriteValueARM64_OpMul32F_0(v *Value) bool {
+func rewriteValueARM64_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -26530,7 +26333,7 @@
return true
}
}
-func rewriteValueARM64_OpMul64_0(v *Value) bool {
+func rewriteValueARM64_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64 x y)
@@ -26544,7 +26347,7 @@
return true
}
}
-func rewriteValueARM64_OpMul64F_0(v *Value) bool {
+func rewriteValueARM64_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -26558,7 +26361,7 @@
return true
}
}
-func rewriteValueARM64_OpMul64uhilo_0(v *Value) bool {
+func rewriteValueARM64_OpMul64uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64uhilo x y)
@@ -26572,7 +26375,7 @@
return true
}
}
-func rewriteValueARM64_OpMul8_0(v *Value) bool {
+func rewriteValueARM64_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -26586,7 +26389,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg16_0(v *Value) bool {
+func rewriteValueARM64_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEG x)
@@ -26597,7 +26400,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg32_0(v *Value) bool {
+func rewriteValueARM64_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEG x)
@@ -26608,7 +26411,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg32F_0(v *Value) bool {
+func rewriteValueARM64_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (FNEGS x)
@@ -26619,7 +26422,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg64_0(v *Value) bool {
+func rewriteValueARM64_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64 x)
// result: (NEG x)
@@ -26630,7 +26433,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg64F_0(v *Value) bool {
+func rewriteValueARM64_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (FNEGD x)
@@ -26641,7 +26444,7 @@
return true
}
}
-func rewriteValueARM64_OpNeg8_0(v *Value) bool {
+func rewriteValueARM64_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEG x)
@@ -26652,7 +26455,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq16_0(v *Value) bool {
+func rewriteValueARM64_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26674,7 +26477,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32_0(v *Value) bool {
+func rewriteValueARM64_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26691,7 +26494,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq32F_0(v *Value) bool {
+func rewriteValueARM64_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26708,7 +26511,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64_0(v *Value) bool {
+func rewriteValueARM64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26725,7 +26528,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq64F_0(v *Value) bool {
+func rewriteValueARM64_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26742,7 +26545,7 @@
return true
}
}
-func rewriteValueARM64_OpNeq8_0(v *Value) bool {
+func rewriteValueARM64_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26764,7 +26567,7 @@
return true
}
}
-func rewriteValueARM64_OpNeqB_0(v *Value) bool {
+func rewriteValueARM64_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -26778,7 +26581,7 @@
return true
}
}
-func rewriteValueARM64_OpNeqPtr_0(v *Value) bool {
+func rewriteValueARM64_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -26795,7 +26598,7 @@
return true
}
}
-func rewriteValueARM64_OpNilCheck_0(v *Value) bool {
+func rewriteValueARM64_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -26809,7 +26612,7 @@
return true
}
}
-func rewriteValueARM64_OpNot_0(v *Value) bool {
+func rewriteValueARM64_OpNot(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -26825,7 +26628,7 @@
return true
}
}
-func rewriteValueARM64_OpOffPtr_0(v *Value) bool {
+func rewriteValueARM64_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVDaddr [off] ptr)
@@ -26851,7 +26654,7 @@
return true
}
}
-func rewriteValueARM64_OpOr16_0(v *Value) bool {
+func rewriteValueARM64_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -26865,7 +26668,7 @@
return true
}
}
-func rewriteValueARM64_OpOr32_0(v *Value) bool {
+func rewriteValueARM64_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -26879,7 +26682,7 @@
return true
}
}
-func rewriteValueARM64_OpOr64_0(v *Value) bool {
+func rewriteValueARM64_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -26893,7 +26696,7 @@
return true
}
}
-func rewriteValueARM64_OpOr8_0(v *Value) bool {
+func rewriteValueARM64_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -26907,7 +26710,7 @@
return true
}
}
-func rewriteValueARM64_OpOrB_0(v *Value) bool {
+func rewriteValueARM64_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -26921,7 +26724,7 @@
return true
}
}
-func rewriteValueARM64_OpPanicBounds_0(v *Value) bool {
+func rewriteValueARM64_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -26981,7 +26784,7 @@
}
return false
}
-func rewriteValueARM64_OpPopCount16_0(v *Value) bool {
+func rewriteValueARM64_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -27004,7 +26807,7 @@
return true
}
}
-func rewriteValueARM64_OpPopCount32_0(v *Value) bool {
+func rewriteValueARM64_OpPopCount32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -27027,7 +26830,7 @@
return true
}
}
-func rewriteValueARM64_OpPopCount64_0(v *Value) bool {
+func rewriteValueARM64_OpPopCount64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -27048,7 +26851,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueARM64_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27079,7 +26882,7 @@
}
return false
}
-func rewriteValueARM64_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueARM64_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27096,7 +26899,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueARM64_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27113,7 +26916,7 @@
return true
}
}
-func rewriteValueARM64_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueARM64_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27144,7 +26947,7 @@
}
return false
}
-func rewriteValueARM64_OpRound_0(v *Value) bool {
+func rewriteValueARM64_OpRound(v *Value) bool {
v_0 := v.Args[0]
// match: (Round x)
// result: (FRINTAD x)
@@ -27155,7 +26958,7 @@
return true
}
}
-func rewriteValueARM64_OpRound32F_0(v *Value) bool {
+func rewriteValueARM64_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: (LoweredRound32F x)
@@ -27166,7 +26969,7 @@
return true
}
}
-func rewriteValueARM64_OpRound64F_0(v *Value) bool {
+func rewriteValueARM64_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: (LoweredRound64F x)
@@ -27177,7 +26980,7 @@
return true
}
}
-func rewriteValueARM64_OpRoundToEven_0(v *Value) bool {
+func rewriteValueARM64_OpRoundToEven(v *Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (FRINTND x)
@@ -27188,7 +26991,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27221,7 +27024,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27254,7 +27057,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27283,7 +27086,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27316,7 +27119,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27348,7 +27151,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27380,7 +27183,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27408,7 +27211,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh16x8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27440,7 +27243,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27473,7 +27276,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27506,7 +27309,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27535,7 +27338,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27568,7 +27371,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27600,7 +27403,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27632,7 +27435,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27660,7 +27463,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh32x8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27692,7 +27495,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27723,7 +27526,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27754,7 +27557,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27780,7 +27583,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27811,7 +27614,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27841,7 +27644,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27871,7 +27674,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27896,7 +27699,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh64x8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27926,7 +27729,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27959,7 +27762,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -27992,7 +27795,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28021,7 +27824,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28054,7 +27857,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x16_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28086,7 +27889,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x32_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28118,7 +27921,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x64_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28146,7 +27949,7 @@
return true
}
}
-func rewriteValueARM64_OpRsh8x8_0(v *Value) bool {
+func rewriteValueARM64_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -28178,7 +27981,7 @@
return true
}
}
-func rewriteValueARM64_OpSelect0_0(v *Value) bool {
+func rewriteValueARM64_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -28229,7 +28032,7 @@
}
return false
}
-func rewriteValueARM64_OpSelect1_0(v *Value) bool {
+func rewriteValueARM64_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -28286,7 +28089,7 @@
}
return false
}
-func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -28297,7 +28100,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 x)
// result: (MOVHreg x)
@@ -28308,7 +28111,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 x)
// result: (MOVWreg x)
@@ -28319,7 +28122,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -28330,7 +28133,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -28341,7 +28144,7 @@
return true
}
}
-func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 x)
// result: (MOVBreg x)
@@ -28352,7 +28155,7 @@
return true
}
}
-func rewriteValueARM64_OpSlicemask_0(v *Value) bool {
+func rewriteValueARM64_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -28368,7 +28171,7 @@
return true
}
}
-func rewriteValueARM64_OpSqrt_0(v *Value) bool {
+func rewriteValueARM64_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (FSQRTD x)
@@ -28379,7 +28182,7 @@
return true
}
}
-func rewriteValueARM64_OpStaticCall_0(v *Value) bool {
+func rewriteValueARM64_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -28394,7 +28197,7 @@
return true
}
}
-func rewriteValueARM64_OpStore_0(v *Value) bool {
+func rewriteValueARM64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -28502,7 +28305,7 @@
}
return false
}
-func rewriteValueARM64_OpSub16_0(v *Value) bool {
+func rewriteValueARM64_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -28516,7 +28319,7 @@
return true
}
}
-func rewriteValueARM64_OpSub32_0(v *Value) bool {
+func rewriteValueARM64_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -28530,7 +28333,7 @@
return true
}
}
-func rewriteValueARM64_OpSub32F_0(v *Value) bool {
+func rewriteValueARM64_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -28544,7 +28347,7 @@
return true
}
}
-func rewriteValueARM64_OpSub64_0(v *Value) bool {
+func rewriteValueARM64_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -28558,7 +28361,7 @@
return true
}
}
-func rewriteValueARM64_OpSub64F_0(v *Value) bool {
+func rewriteValueARM64_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -28572,7 +28375,7 @@
return true
}
}
-func rewriteValueARM64_OpSub8_0(v *Value) bool {
+func rewriteValueARM64_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -28586,7 +28389,7 @@
return true
}
}
-func rewriteValueARM64_OpSubPtr_0(v *Value) bool {
+func rewriteValueARM64_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -28600,7 +28403,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (FRINTZD x)
@@ -28611,7 +28414,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -28623,7 +28426,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -28635,7 +28438,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -28647,7 +28450,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 x)
// result: x
@@ -28659,7 +28462,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 x)
// result: x
@@ -28671,7 +28474,7 @@
return true
}
}
-func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 x)
// result: x
@@ -28683,7 +28486,7 @@
return true
}
}
-func rewriteValueARM64_OpWB_0(v *Value) bool {
+func rewriteValueARM64_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -28702,7 +28505,7 @@
return true
}
}
-func rewriteValueARM64_OpXor16_0(v *Value) bool {
+func rewriteValueARM64_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -28716,7 +28519,7 @@
return true
}
}
-func rewriteValueARM64_OpXor32_0(v *Value) bool {
+func rewriteValueARM64_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -28730,7 +28533,7 @@
return true
}
}
-func rewriteValueARM64_OpXor64_0(v *Value) bool {
+func rewriteValueARM64_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -28744,7 +28547,7 @@
return true
}
}
-func rewriteValueARM64_OpXor8_0(v *Value) bool {
+func rewriteValueARM64_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -28758,10 +28561,11 @@
return true
}
}
-func rewriteValueARM64_OpZero_0(v *Value) bool {
+func rewriteValueARM64_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Zero [0] _ mem)
// result: mem
@@ -28961,13 +28765,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueARM64_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Zero [10] ptr mem)
// result: (MOVHstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
for {
@@ -29281,13 +29078,6 @@
v.AddArg(v2)
return true
}
- return false
-}
-func rewriteValueARM64_OpZero_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
// match: (Zero [s] ptr mem)
// cond: s%16 != 0 && s%16 <= 8 && s > 16
// result: (Zero [8] (OffPtr <ptr.Type> ptr [s-8]) (Zero [s-s%16] ptr mem))
@@ -29371,7 +29161,7 @@
}
return false
}
-func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHUreg x)
@@ -29382,7 +29172,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 x)
// result: (MOVHUreg x)
@@ -29393,7 +29183,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 x)
// result: (MOVWUreg x)
@@ -29404,7 +29194,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBUreg x)
@@ -29415,7 +29205,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBUreg x)
@@ -29426,7 +29216,7 @@
return true
}
}
-func rewriteValueARM64_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 x)
// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go
index 47adca6..3058ecb 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go
@@ -8,523 +8,523 @@
func rewriteValueMIPS(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS_OpAdd16_0(v)
+ return rewriteValueMIPS_OpAdd16(v)
case OpAdd32:
- return rewriteValueMIPS_OpAdd32_0(v)
+ return rewriteValueMIPS_OpAdd32(v)
case OpAdd32F:
- return rewriteValueMIPS_OpAdd32F_0(v)
+ return rewriteValueMIPS_OpAdd32F(v)
case OpAdd32withcarry:
- return rewriteValueMIPS_OpAdd32withcarry_0(v)
+ return rewriteValueMIPS_OpAdd32withcarry(v)
case OpAdd64F:
- return rewriteValueMIPS_OpAdd64F_0(v)
+ return rewriteValueMIPS_OpAdd64F(v)
case OpAdd8:
- return rewriteValueMIPS_OpAdd8_0(v)
+ return rewriteValueMIPS_OpAdd8(v)
case OpAddPtr:
- return rewriteValueMIPS_OpAddPtr_0(v)
+ return rewriteValueMIPS_OpAddPtr(v)
case OpAddr:
- return rewriteValueMIPS_OpAddr_0(v)
+ return rewriteValueMIPS_OpAddr(v)
case OpAnd16:
- return rewriteValueMIPS_OpAnd16_0(v)
+ return rewriteValueMIPS_OpAnd16(v)
case OpAnd32:
- return rewriteValueMIPS_OpAnd32_0(v)
+ return rewriteValueMIPS_OpAnd32(v)
case OpAnd8:
- return rewriteValueMIPS_OpAnd8_0(v)
+ return rewriteValueMIPS_OpAnd8(v)
case OpAndB:
- return rewriteValueMIPS_OpAndB_0(v)
+ return rewriteValueMIPS_OpAndB(v)
case OpAtomicAdd32:
- return rewriteValueMIPS_OpAtomicAdd32_0(v)
+ return rewriteValueMIPS_OpAtomicAdd32(v)
case OpAtomicAnd8:
- return rewriteValueMIPS_OpAtomicAnd8_0(v)
+ return rewriteValueMIPS_OpAtomicAnd8(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v)
+ return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
case OpAtomicExchange32:
- return rewriteValueMIPS_OpAtomicExchange32_0(v)
+ return rewriteValueMIPS_OpAtomicExchange32(v)
case OpAtomicLoad32:
- return rewriteValueMIPS_OpAtomicLoad32_0(v)
+ return rewriteValueMIPS_OpAtomicLoad32(v)
case OpAtomicLoad8:
- return rewriteValueMIPS_OpAtomicLoad8_0(v)
+ return rewriteValueMIPS_OpAtomicLoad8(v)
case OpAtomicLoadPtr:
- return rewriteValueMIPS_OpAtomicLoadPtr_0(v)
+ return rewriteValueMIPS_OpAtomicLoadPtr(v)
case OpAtomicOr8:
- return rewriteValueMIPS_OpAtomicOr8_0(v)
+ return rewriteValueMIPS_OpAtomicOr8(v)
case OpAtomicStore32:
- return rewriteValueMIPS_OpAtomicStore32_0(v)
+ return rewriteValueMIPS_OpAtomicStore32(v)
case OpAtomicStore8:
- return rewriteValueMIPS_OpAtomicStore8_0(v)
+ return rewriteValueMIPS_OpAtomicStore8(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v)
+ return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
case OpAvg32u:
- return rewriteValueMIPS_OpAvg32u_0(v)
+ return rewriteValueMIPS_OpAvg32u(v)
case OpBitLen32:
- return rewriteValueMIPS_OpBitLen32_0(v)
+ return rewriteValueMIPS_OpBitLen32(v)
case OpClosureCall:
- return rewriteValueMIPS_OpClosureCall_0(v)
+ return rewriteValueMIPS_OpClosureCall(v)
case OpCom16:
- return rewriteValueMIPS_OpCom16_0(v)
+ return rewriteValueMIPS_OpCom16(v)
case OpCom32:
- return rewriteValueMIPS_OpCom32_0(v)
+ return rewriteValueMIPS_OpCom32(v)
case OpCom8:
- return rewriteValueMIPS_OpCom8_0(v)
+ return rewriteValueMIPS_OpCom8(v)
case OpConst16:
- return rewriteValueMIPS_OpConst16_0(v)
+ return rewriteValueMIPS_OpConst16(v)
case OpConst32:
- return rewriteValueMIPS_OpConst32_0(v)
+ return rewriteValueMIPS_OpConst32(v)
case OpConst32F:
- return rewriteValueMIPS_OpConst32F_0(v)
+ return rewriteValueMIPS_OpConst32F(v)
case OpConst64F:
- return rewriteValueMIPS_OpConst64F_0(v)
+ return rewriteValueMIPS_OpConst64F(v)
case OpConst8:
- return rewriteValueMIPS_OpConst8_0(v)
+ return rewriteValueMIPS_OpConst8(v)
case OpConstBool:
- return rewriteValueMIPS_OpConstBool_0(v)
+ return rewriteValueMIPS_OpConstBool(v)
case OpConstNil:
- return rewriteValueMIPS_OpConstNil_0(v)
+ return rewriteValueMIPS_OpConstNil(v)
case OpCtz32:
- return rewriteValueMIPS_OpCtz32_0(v)
+ return rewriteValueMIPS_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueMIPS_OpCtz32NonZero_0(v)
+ return rewriteValueMIPS_OpCtz32NonZero(v)
case OpCvt32Fto32:
- return rewriteValueMIPS_OpCvt32Fto32_0(v)
+ return rewriteValueMIPS_OpCvt32Fto32(v)
case OpCvt32Fto64F:
- return rewriteValueMIPS_OpCvt32Fto64F_0(v)
+ return rewriteValueMIPS_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValueMIPS_OpCvt32to32F_0(v)
+ return rewriteValueMIPS_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueMIPS_OpCvt32to64F_0(v)
+ return rewriteValueMIPS_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueMIPS_OpCvt64Fto32_0(v)
+ return rewriteValueMIPS_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueMIPS_OpCvt64Fto32F_0(v)
+ return rewriteValueMIPS_OpCvt64Fto32F(v)
case OpDiv16:
- return rewriteValueMIPS_OpDiv16_0(v)
+ return rewriteValueMIPS_OpDiv16(v)
case OpDiv16u:
- return rewriteValueMIPS_OpDiv16u_0(v)
+ return rewriteValueMIPS_OpDiv16u(v)
case OpDiv32:
- return rewriteValueMIPS_OpDiv32_0(v)
+ return rewriteValueMIPS_OpDiv32(v)
case OpDiv32F:
- return rewriteValueMIPS_OpDiv32F_0(v)
+ return rewriteValueMIPS_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueMIPS_OpDiv32u_0(v)
+ return rewriteValueMIPS_OpDiv32u(v)
case OpDiv64F:
- return rewriteValueMIPS_OpDiv64F_0(v)
+ return rewriteValueMIPS_OpDiv64F(v)
case OpDiv8:
- return rewriteValueMIPS_OpDiv8_0(v)
+ return rewriteValueMIPS_OpDiv8(v)
case OpDiv8u:
- return rewriteValueMIPS_OpDiv8u_0(v)
+ return rewriteValueMIPS_OpDiv8u(v)
case OpEq16:
- return rewriteValueMIPS_OpEq16_0(v)
+ return rewriteValueMIPS_OpEq16(v)
case OpEq32:
- return rewriteValueMIPS_OpEq32_0(v)
+ return rewriteValueMIPS_OpEq32(v)
case OpEq32F:
- return rewriteValueMIPS_OpEq32F_0(v)
+ return rewriteValueMIPS_OpEq32F(v)
case OpEq64F:
- return rewriteValueMIPS_OpEq64F_0(v)
+ return rewriteValueMIPS_OpEq64F(v)
case OpEq8:
- return rewriteValueMIPS_OpEq8_0(v)
+ return rewriteValueMIPS_OpEq8(v)
case OpEqB:
- return rewriteValueMIPS_OpEqB_0(v)
+ return rewriteValueMIPS_OpEqB(v)
case OpEqPtr:
- return rewriteValueMIPS_OpEqPtr_0(v)
+ return rewriteValueMIPS_OpEqPtr(v)
case OpGeq16:
- return rewriteValueMIPS_OpGeq16_0(v)
+ return rewriteValueMIPS_OpGeq16(v)
case OpGeq16U:
- return rewriteValueMIPS_OpGeq16U_0(v)
+ return rewriteValueMIPS_OpGeq16U(v)
case OpGeq32:
- return rewriteValueMIPS_OpGeq32_0(v)
+ return rewriteValueMIPS_OpGeq32(v)
case OpGeq32F:
- return rewriteValueMIPS_OpGeq32F_0(v)
+ return rewriteValueMIPS_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueMIPS_OpGeq32U_0(v)
+ return rewriteValueMIPS_OpGeq32U(v)
case OpGeq64F:
- return rewriteValueMIPS_OpGeq64F_0(v)
+ return rewriteValueMIPS_OpGeq64F(v)
case OpGeq8:
- return rewriteValueMIPS_OpGeq8_0(v)
+ return rewriteValueMIPS_OpGeq8(v)
case OpGeq8U:
- return rewriteValueMIPS_OpGeq8U_0(v)
+ return rewriteValueMIPS_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueMIPS_OpGetCallerPC_0(v)
+ return rewriteValueMIPS_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueMIPS_OpGetCallerSP_0(v)
+ return rewriteValueMIPS_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueMIPS_OpGetClosurePtr_0(v)
+ return rewriteValueMIPS_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueMIPS_OpGreater16_0(v)
+ return rewriteValueMIPS_OpGreater16(v)
case OpGreater16U:
- return rewriteValueMIPS_OpGreater16U_0(v)
+ return rewriteValueMIPS_OpGreater16U(v)
case OpGreater32:
- return rewriteValueMIPS_OpGreater32_0(v)
+ return rewriteValueMIPS_OpGreater32(v)
case OpGreater32F:
- return rewriteValueMIPS_OpGreater32F_0(v)
+ return rewriteValueMIPS_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueMIPS_OpGreater32U_0(v)
+ return rewriteValueMIPS_OpGreater32U(v)
case OpGreater64F:
- return rewriteValueMIPS_OpGreater64F_0(v)
+ return rewriteValueMIPS_OpGreater64F(v)
case OpGreater8:
- return rewriteValueMIPS_OpGreater8_0(v)
+ return rewriteValueMIPS_OpGreater8(v)
case OpGreater8U:
- return rewriteValueMIPS_OpGreater8U_0(v)
+ return rewriteValueMIPS_OpGreater8U(v)
case OpHmul32:
- return rewriteValueMIPS_OpHmul32_0(v)
+ return rewriteValueMIPS_OpHmul32(v)
case OpHmul32u:
- return rewriteValueMIPS_OpHmul32u_0(v)
+ return rewriteValueMIPS_OpHmul32u(v)
case OpInterCall:
- return rewriteValueMIPS_OpInterCall_0(v)
+ return rewriteValueMIPS_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueMIPS_OpIsInBounds_0(v)
+ return rewriteValueMIPS_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueMIPS_OpIsNonNil_0(v)
+ return rewriteValueMIPS_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueMIPS_OpIsSliceInBounds_0(v)
+ return rewriteValueMIPS_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueMIPS_OpLeq16_0(v)
+ return rewriteValueMIPS_OpLeq16(v)
case OpLeq16U:
- return rewriteValueMIPS_OpLeq16U_0(v)
+ return rewriteValueMIPS_OpLeq16U(v)
case OpLeq32:
- return rewriteValueMIPS_OpLeq32_0(v)
+ return rewriteValueMIPS_OpLeq32(v)
case OpLeq32F:
- return rewriteValueMIPS_OpLeq32F_0(v)
+ return rewriteValueMIPS_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueMIPS_OpLeq32U_0(v)
+ return rewriteValueMIPS_OpLeq32U(v)
case OpLeq64F:
- return rewriteValueMIPS_OpLeq64F_0(v)
+ return rewriteValueMIPS_OpLeq64F(v)
case OpLeq8:
- return rewriteValueMIPS_OpLeq8_0(v)
+ return rewriteValueMIPS_OpLeq8(v)
case OpLeq8U:
- return rewriteValueMIPS_OpLeq8U_0(v)
+ return rewriteValueMIPS_OpLeq8U(v)
case OpLess16:
- return rewriteValueMIPS_OpLess16_0(v)
+ return rewriteValueMIPS_OpLess16(v)
case OpLess16U:
- return rewriteValueMIPS_OpLess16U_0(v)
+ return rewriteValueMIPS_OpLess16U(v)
case OpLess32:
- return rewriteValueMIPS_OpLess32_0(v)
+ return rewriteValueMIPS_OpLess32(v)
case OpLess32F:
- return rewriteValueMIPS_OpLess32F_0(v)
+ return rewriteValueMIPS_OpLess32F(v)
case OpLess32U:
- return rewriteValueMIPS_OpLess32U_0(v)
+ return rewriteValueMIPS_OpLess32U(v)
case OpLess64F:
- return rewriteValueMIPS_OpLess64F_0(v)
+ return rewriteValueMIPS_OpLess64F(v)
case OpLess8:
- return rewriteValueMIPS_OpLess8_0(v)
+ return rewriteValueMIPS_OpLess8(v)
case OpLess8U:
- return rewriteValueMIPS_OpLess8U_0(v)
+ return rewriteValueMIPS_OpLess8U(v)
case OpLoad:
- return rewriteValueMIPS_OpLoad_0(v)
+ return rewriteValueMIPS_OpLoad(v)
case OpLocalAddr:
- return rewriteValueMIPS_OpLocalAddr_0(v)
+ return rewriteValueMIPS_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueMIPS_OpLsh16x16_0(v)
+ return rewriteValueMIPS_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueMIPS_OpLsh16x32_0(v)
+ return rewriteValueMIPS_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueMIPS_OpLsh16x64_0(v)
+ return rewriteValueMIPS_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueMIPS_OpLsh16x8_0(v)
+ return rewriteValueMIPS_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueMIPS_OpLsh32x16_0(v)
+ return rewriteValueMIPS_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueMIPS_OpLsh32x32_0(v)
+ return rewriteValueMIPS_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueMIPS_OpLsh32x64_0(v)
+ return rewriteValueMIPS_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueMIPS_OpLsh32x8_0(v)
+ return rewriteValueMIPS_OpLsh32x8(v)
case OpLsh8x16:
- return rewriteValueMIPS_OpLsh8x16_0(v)
+ return rewriteValueMIPS_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueMIPS_OpLsh8x32_0(v)
+ return rewriteValueMIPS_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueMIPS_OpLsh8x64_0(v)
+ return rewriteValueMIPS_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueMIPS_OpLsh8x8_0(v)
+ return rewriteValueMIPS_OpLsh8x8(v)
case OpMIPSADD:
- return rewriteValueMIPS_OpMIPSADD_0(v)
+ return rewriteValueMIPS_OpMIPSADD(v)
case OpMIPSADDconst:
- return rewriteValueMIPS_OpMIPSADDconst_0(v)
+ return rewriteValueMIPS_OpMIPSADDconst(v)
case OpMIPSAND:
- return rewriteValueMIPS_OpMIPSAND_0(v)
+ return rewriteValueMIPS_OpMIPSAND(v)
case OpMIPSANDconst:
- return rewriteValueMIPS_OpMIPSANDconst_0(v)
+ return rewriteValueMIPS_OpMIPSANDconst(v)
case OpMIPSCMOVZ:
- return rewriteValueMIPS_OpMIPSCMOVZ_0(v)
+ return rewriteValueMIPS_OpMIPSCMOVZ(v)
case OpMIPSCMOVZzero:
- return rewriteValueMIPS_OpMIPSCMOVZzero_0(v)
+ return rewriteValueMIPS_OpMIPSCMOVZzero(v)
case OpMIPSLoweredAtomicAdd:
- return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v)
+ return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
case OpMIPSLoweredAtomicStore32:
- return rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v)
+ return rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v)
case OpMIPSMOVBUload:
- return rewriteValueMIPS_OpMIPSMOVBUload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBUload(v)
case OpMIPSMOVBUreg:
- return rewriteValueMIPS_OpMIPSMOVBUreg_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBUreg(v)
case OpMIPSMOVBload:
- return rewriteValueMIPS_OpMIPSMOVBload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBload(v)
case OpMIPSMOVBreg:
- return rewriteValueMIPS_OpMIPSMOVBreg_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBreg(v)
case OpMIPSMOVBstore:
- return rewriteValueMIPS_OpMIPSMOVBstore_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBstore(v)
case OpMIPSMOVBstorezero:
- return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v)
+ return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
case OpMIPSMOVDload:
- return rewriteValueMIPS_OpMIPSMOVDload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVDload(v)
case OpMIPSMOVDstore:
- return rewriteValueMIPS_OpMIPSMOVDstore_0(v)
+ return rewriteValueMIPS_OpMIPSMOVDstore(v)
case OpMIPSMOVFload:
- return rewriteValueMIPS_OpMIPSMOVFload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVFload(v)
case OpMIPSMOVFstore:
- return rewriteValueMIPS_OpMIPSMOVFstore_0(v)
+ return rewriteValueMIPS_OpMIPSMOVFstore(v)
case OpMIPSMOVHUload:
- return rewriteValueMIPS_OpMIPSMOVHUload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHUload(v)
case OpMIPSMOVHUreg:
- return rewriteValueMIPS_OpMIPSMOVHUreg_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHUreg(v)
case OpMIPSMOVHload:
- return rewriteValueMIPS_OpMIPSMOVHload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHload(v)
case OpMIPSMOVHreg:
- return rewriteValueMIPS_OpMIPSMOVHreg_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHreg(v)
case OpMIPSMOVHstore:
- return rewriteValueMIPS_OpMIPSMOVHstore_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHstore(v)
case OpMIPSMOVHstorezero:
- return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v)
+ return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
case OpMIPSMOVWload:
- return rewriteValueMIPS_OpMIPSMOVWload_0(v)
+ return rewriteValueMIPS_OpMIPSMOVWload(v)
case OpMIPSMOVWreg:
- return rewriteValueMIPS_OpMIPSMOVWreg_0(v)
+ return rewriteValueMIPS_OpMIPSMOVWreg(v)
case OpMIPSMOVWstore:
- return rewriteValueMIPS_OpMIPSMOVWstore_0(v)
+ return rewriteValueMIPS_OpMIPSMOVWstore(v)
case OpMIPSMOVWstorezero:
- return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v)
+ return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
case OpMIPSMUL:
- return rewriteValueMIPS_OpMIPSMUL_0(v)
+ return rewriteValueMIPS_OpMIPSMUL(v)
case OpMIPSNEG:
- return rewriteValueMIPS_OpMIPSNEG_0(v)
+ return rewriteValueMIPS_OpMIPSNEG(v)
case OpMIPSNOR:
- return rewriteValueMIPS_OpMIPSNOR_0(v)
+ return rewriteValueMIPS_OpMIPSNOR(v)
case OpMIPSNORconst:
- return rewriteValueMIPS_OpMIPSNORconst_0(v)
+ return rewriteValueMIPS_OpMIPSNORconst(v)
case OpMIPSOR:
- return rewriteValueMIPS_OpMIPSOR_0(v)
+ return rewriteValueMIPS_OpMIPSOR(v)
case OpMIPSORconst:
- return rewriteValueMIPS_OpMIPSORconst_0(v)
+ return rewriteValueMIPS_OpMIPSORconst(v)
case OpMIPSSGT:
- return rewriteValueMIPS_OpMIPSSGT_0(v)
+ return rewriteValueMIPS_OpMIPSSGT(v)
case OpMIPSSGTU:
- return rewriteValueMIPS_OpMIPSSGTU_0(v)
+ return rewriteValueMIPS_OpMIPSSGTU(v)
case OpMIPSSGTUconst:
- return rewriteValueMIPS_OpMIPSSGTUconst_0(v)
+ return rewriteValueMIPS_OpMIPSSGTUconst(v)
case OpMIPSSGTUzero:
- return rewriteValueMIPS_OpMIPSSGTUzero_0(v)
+ return rewriteValueMIPS_OpMIPSSGTUzero(v)
case OpMIPSSGTconst:
- return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v)
+ return rewriteValueMIPS_OpMIPSSGTconst(v)
case OpMIPSSGTzero:
- return rewriteValueMIPS_OpMIPSSGTzero_0(v)
+ return rewriteValueMIPS_OpMIPSSGTzero(v)
case OpMIPSSLL:
- return rewriteValueMIPS_OpMIPSSLL_0(v)
+ return rewriteValueMIPS_OpMIPSSLL(v)
case OpMIPSSLLconst:
- return rewriteValueMIPS_OpMIPSSLLconst_0(v)
+ return rewriteValueMIPS_OpMIPSSLLconst(v)
case OpMIPSSRA:
- return rewriteValueMIPS_OpMIPSSRA_0(v)
+ return rewriteValueMIPS_OpMIPSSRA(v)
case OpMIPSSRAconst:
- return rewriteValueMIPS_OpMIPSSRAconst_0(v)
+ return rewriteValueMIPS_OpMIPSSRAconst(v)
case OpMIPSSRL:
- return rewriteValueMIPS_OpMIPSSRL_0(v)
+ return rewriteValueMIPS_OpMIPSSRL(v)
case OpMIPSSRLconst:
- return rewriteValueMIPS_OpMIPSSRLconst_0(v)
+ return rewriteValueMIPS_OpMIPSSRLconst(v)
case OpMIPSSUB:
- return rewriteValueMIPS_OpMIPSSUB_0(v)
+ return rewriteValueMIPS_OpMIPSSUB(v)
case OpMIPSSUBconst:
- return rewriteValueMIPS_OpMIPSSUBconst_0(v)
+ return rewriteValueMIPS_OpMIPSSUBconst(v)
case OpMIPSXOR:
- return rewriteValueMIPS_OpMIPSXOR_0(v)
+ return rewriteValueMIPS_OpMIPSXOR(v)
case OpMIPSXORconst:
- return rewriteValueMIPS_OpMIPSXORconst_0(v)
+ return rewriteValueMIPS_OpMIPSXORconst(v)
case OpMod16:
- return rewriteValueMIPS_OpMod16_0(v)
+ return rewriteValueMIPS_OpMod16(v)
case OpMod16u:
- return rewriteValueMIPS_OpMod16u_0(v)
+ return rewriteValueMIPS_OpMod16u(v)
case OpMod32:
- return rewriteValueMIPS_OpMod32_0(v)
+ return rewriteValueMIPS_OpMod32(v)
case OpMod32u:
- return rewriteValueMIPS_OpMod32u_0(v)
+ return rewriteValueMIPS_OpMod32u(v)
case OpMod8:
- return rewriteValueMIPS_OpMod8_0(v)
+ return rewriteValueMIPS_OpMod8(v)
case OpMod8u:
- return rewriteValueMIPS_OpMod8u_0(v)
+ return rewriteValueMIPS_OpMod8u(v)
case OpMove:
- return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v)
+ return rewriteValueMIPS_OpMove(v)
case OpMul16:
- return rewriteValueMIPS_OpMul16_0(v)
+ return rewriteValueMIPS_OpMul16(v)
case OpMul32:
- return rewriteValueMIPS_OpMul32_0(v)
+ return rewriteValueMIPS_OpMul32(v)
case OpMul32F:
- return rewriteValueMIPS_OpMul32F_0(v)
+ return rewriteValueMIPS_OpMul32F(v)
case OpMul32uhilo:
- return rewriteValueMIPS_OpMul32uhilo_0(v)
+ return rewriteValueMIPS_OpMul32uhilo(v)
case OpMul64F:
- return rewriteValueMIPS_OpMul64F_0(v)
+ return rewriteValueMIPS_OpMul64F(v)
case OpMul8:
- return rewriteValueMIPS_OpMul8_0(v)
+ return rewriteValueMIPS_OpMul8(v)
case OpNeg16:
- return rewriteValueMIPS_OpNeg16_0(v)
+ return rewriteValueMIPS_OpNeg16(v)
case OpNeg32:
- return rewriteValueMIPS_OpNeg32_0(v)
+ return rewriteValueMIPS_OpNeg32(v)
case OpNeg32F:
- return rewriteValueMIPS_OpNeg32F_0(v)
+ return rewriteValueMIPS_OpNeg32F(v)
case OpNeg64F:
- return rewriteValueMIPS_OpNeg64F_0(v)
+ return rewriteValueMIPS_OpNeg64F(v)
case OpNeg8:
- return rewriteValueMIPS_OpNeg8_0(v)
+ return rewriteValueMIPS_OpNeg8(v)
case OpNeq16:
- return rewriteValueMIPS_OpNeq16_0(v)
+ return rewriteValueMIPS_OpNeq16(v)
case OpNeq32:
- return rewriteValueMIPS_OpNeq32_0(v)
+ return rewriteValueMIPS_OpNeq32(v)
case OpNeq32F:
- return rewriteValueMIPS_OpNeq32F_0(v)
+ return rewriteValueMIPS_OpNeq32F(v)
case OpNeq64F:
- return rewriteValueMIPS_OpNeq64F_0(v)
+ return rewriteValueMIPS_OpNeq64F(v)
case OpNeq8:
- return rewriteValueMIPS_OpNeq8_0(v)
+ return rewriteValueMIPS_OpNeq8(v)
case OpNeqB:
- return rewriteValueMIPS_OpNeqB_0(v)
+ return rewriteValueMIPS_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueMIPS_OpNeqPtr_0(v)
+ return rewriteValueMIPS_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueMIPS_OpNilCheck_0(v)
+ return rewriteValueMIPS_OpNilCheck(v)
case OpNot:
- return rewriteValueMIPS_OpNot_0(v)
+ return rewriteValueMIPS_OpNot(v)
case OpOffPtr:
- return rewriteValueMIPS_OpOffPtr_0(v)
+ return rewriteValueMIPS_OpOffPtr(v)
case OpOr16:
- return rewriteValueMIPS_OpOr16_0(v)
+ return rewriteValueMIPS_OpOr16(v)
case OpOr32:
- return rewriteValueMIPS_OpOr32_0(v)
+ return rewriteValueMIPS_OpOr32(v)
case OpOr8:
- return rewriteValueMIPS_OpOr8_0(v)
+ return rewriteValueMIPS_OpOr8(v)
case OpOrB:
- return rewriteValueMIPS_OpOrB_0(v)
+ return rewriteValueMIPS_OpOrB(v)
case OpPanicBounds:
- return rewriteValueMIPS_OpPanicBounds_0(v)
+ return rewriteValueMIPS_OpPanicBounds(v)
case OpPanicExtend:
- return rewriteValueMIPS_OpPanicExtend_0(v)
+ return rewriteValueMIPS_OpPanicExtend(v)
case OpRotateLeft16:
- return rewriteValueMIPS_OpRotateLeft16_0(v)
+ return rewriteValueMIPS_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueMIPS_OpRotateLeft32_0(v)
+ return rewriteValueMIPS_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueMIPS_OpRotateLeft64_0(v)
+ return rewriteValueMIPS_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueMIPS_OpRotateLeft8_0(v)
+ return rewriteValueMIPS_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueMIPS_OpRound32F_0(v)
+ return rewriteValueMIPS_OpRound32F(v)
case OpRound64F:
- return rewriteValueMIPS_OpRound64F_0(v)
+ return rewriteValueMIPS_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValueMIPS_OpRsh16Ux16_0(v)
+ return rewriteValueMIPS_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueMIPS_OpRsh16Ux32_0(v)
+ return rewriteValueMIPS_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueMIPS_OpRsh16Ux64_0(v)
+ return rewriteValueMIPS_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueMIPS_OpRsh16Ux8_0(v)
+ return rewriteValueMIPS_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueMIPS_OpRsh16x16_0(v)
+ return rewriteValueMIPS_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueMIPS_OpRsh16x32_0(v)
+ return rewriteValueMIPS_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueMIPS_OpRsh16x64_0(v)
+ return rewriteValueMIPS_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueMIPS_OpRsh16x8_0(v)
+ return rewriteValueMIPS_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueMIPS_OpRsh32Ux16_0(v)
+ return rewriteValueMIPS_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueMIPS_OpRsh32Ux32_0(v)
+ return rewriteValueMIPS_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueMIPS_OpRsh32Ux64_0(v)
+ return rewriteValueMIPS_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueMIPS_OpRsh32Ux8_0(v)
+ return rewriteValueMIPS_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueMIPS_OpRsh32x16_0(v)
+ return rewriteValueMIPS_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueMIPS_OpRsh32x32_0(v)
+ return rewriteValueMIPS_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueMIPS_OpRsh32x64_0(v)
+ return rewriteValueMIPS_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueMIPS_OpRsh32x8_0(v)
+ return rewriteValueMIPS_OpRsh32x8(v)
case OpRsh8Ux16:
- return rewriteValueMIPS_OpRsh8Ux16_0(v)
+ return rewriteValueMIPS_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueMIPS_OpRsh8Ux32_0(v)
+ return rewriteValueMIPS_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueMIPS_OpRsh8Ux64_0(v)
+ return rewriteValueMIPS_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueMIPS_OpRsh8Ux8_0(v)
+ return rewriteValueMIPS_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueMIPS_OpRsh8x16_0(v)
+ return rewriteValueMIPS_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueMIPS_OpRsh8x32_0(v)
+ return rewriteValueMIPS_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueMIPS_OpRsh8x64_0(v)
+ return rewriteValueMIPS_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueMIPS_OpRsh8x8_0(v)
+ return rewriteValueMIPS_OpRsh8x8(v)
case OpSelect0:
- return rewriteValueMIPS_OpSelect0_0(v)
+ return rewriteValueMIPS_OpSelect0(v)
case OpSelect1:
- return rewriteValueMIPS_OpSelect1_0(v)
+ return rewriteValueMIPS_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueMIPS_OpSignExt16to32_0(v)
+ return rewriteValueMIPS_OpSignExt16to32(v)
case OpSignExt8to16:
- return rewriteValueMIPS_OpSignExt8to16_0(v)
+ return rewriteValueMIPS_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueMIPS_OpSignExt8to32_0(v)
+ return rewriteValueMIPS_OpSignExt8to32(v)
case OpSignmask:
- return rewriteValueMIPS_OpSignmask_0(v)
+ return rewriteValueMIPS_OpSignmask(v)
case OpSlicemask:
- return rewriteValueMIPS_OpSlicemask_0(v)
+ return rewriteValueMIPS_OpSlicemask(v)
case OpSqrt:
- return rewriteValueMIPS_OpSqrt_0(v)
+ return rewriteValueMIPS_OpSqrt(v)
case OpStaticCall:
- return rewriteValueMIPS_OpStaticCall_0(v)
+ return rewriteValueMIPS_OpStaticCall(v)
case OpStore:
- return rewriteValueMIPS_OpStore_0(v)
+ return rewriteValueMIPS_OpStore(v)
case OpSub16:
- return rewriteValueMIPS_OpSub16_0(v)
+ return rewriteValueMIPS_OpSub16(v)
case OpSub32:
- return rewriteValueMIPS_OpSub32_0(v)
+ return rewriteValueMIPS_OpSub32(v)
case OpSub32F:
- return rewriteValueMIPS_OpSub32F_0(v)
+ return rewriteValueMIPS_OpSub32F(v)
case OpSub32withcarry:
- return rewriteValueMIPS_OpSub32withcarry_0(v)
+ return rewriteValueMIPS_OpSub32withcarry(v)
case OpSub64F:
- return rewriteValueMIPS_OpSub64F_0(v)
+ return rewriteValueMIPS_OpSub64F(v)
case OpSub8:
- return rewriteValueMIPS_OpSub8_0(v)
+ return rewriteValueMIPS_OpSub8(v)
case OpSubPtr:
- return rewriteValueMIPS_OpSubPtr_0(v)
+ return rewriteValueMIPS_OpSubPtr(v)
case OpTrunc16to8:
- return rewriteValueMIPS_OpTrunc16to8_0(v)
+ return rewriteValueMIPS_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueMIPS_OpTrunc32to16_0(v)
+ return rewriteValueMIPS_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueMIPS_OpTrunc32to8_0(v)
+ return rewriteValueMIPS_OpTrunc32to8(v)
case OpWB:
- return rewriteValueMIPS_OpWB_0(v)
+ return rewriteValueMIPS_OpWB(v)
case OpXor16:
- return rewriteValueMIPS_OpXor16_0(v)
+ return rewriteValueMIPS_OpXor16(v)
case OpXor32:
- return rewriteValueMIPS_OpXor32_0(v)
+ return rewriteValueMIPS_OpXor32(v)
case OpXor8:
- return rewriteValueMIPS_OpXor8_0(v)
+ return rewriteValueMIPS_OpXor8(v)
case OpZero:
- return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v)
+ return rewriteValueMIPS_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueMIPS_OpZeroExt16to32_0(v)
+ return rewriteValueMIPS_OpZeroExt16to32(v)
case OpZeroExt8to16:
- return rewriteValueMIPS_OpZeroExt8to16_0(v)
+ return rewriteValueMIPS_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueMIPS_OpZeroExt8to32_0(v)
+ return rewriteValueMIPS_OpZeroExt8to32(v)
case OpZeromask:
- return rewriteValueMIPS_OpZeromask_0(v)
+ return rewriteValueMIPS_OpZeromask(v)
}
return false
}
-func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -538,7 +538,7 @@
return true
}
}
-func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -552,7 +552,7 @@
return true
}
}
-func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -566,7 +566,7 @@
return true
}
}
-func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -587,7 +587,7 @@
return true
}
}
-func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -601,7 +601,7 @@
return true
}
}
-func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -615,7 +615,7 @@
return true
}
}
-func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -629,7 +629,7 @@
return true
}
}
-func rewriteValueMIPS_OpAddr_0(v *Value) bool {
+func rewriteValueMIPS_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVWaddr {sym} base)
@@ -642,7 +642,7 @@
return true
}
}
-func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -656,7 +656,7 @@
return true
}
}
-func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -670,7 +670,7 @@
return true
}
}
-func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -684,7 +684,7 @@
return true
}
}
-func rewriteValueMIPS_OpAndB_0(v *Value) bool {
+func rewriteValueMIPS_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -698,7 +698,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -715,7 +715,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -828,7 +828,7 @@
}
return false
}
-func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -848,7 +848,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -865,7 +865,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -879,7 +879,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -893,7 +893,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -907,7 +907,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -983,7 +983,7 @@
}
return false
}
-func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1000,7 +1000,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1017,7 +1017,7 @@
return true
}
}
-func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1034,7 +1034,7 @@
return true
}
}
-func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
+func rewriteValueMIPS_OpAvg32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1056,7 +1056,7 @@
return true
}
}
-func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
+func rewriteValueMIPS_OpBitLen32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1075,7 +1075,7 @@
return true
}
}
-func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
+func rewriteValueMIPS_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1094,7 +1094,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom16_0(v *Value) bool {
+func rewriteValueMIPS_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (NORconst [0] x)
@@ -1106,7 +1106,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom32_0(v *Value) bool {
+func rewriteValueMIPS_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (NORconst [0] x)
@@ -1118,7 +1118,7 @@
return true
}
}
-func rewriteValueMIPS_OpCom8_0(v *Value) bool {
+func rewriteValueMIPS_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (NORconst [0] x)
@@ -1130,7 +1130,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst16_0(v *Value) bool {
+func rewriteValueMIPS_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVWconst [val])
for {
@@ -1140,7 +1140,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst32_0(v *Value) bool {
+func rewriteValueMIPS_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVWconst [val])
for {
@@ -1150,7 +1150,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
+func rewriteValueMIPS_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [val])
for {
@@ -1160,7 +1160,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
+func rewriteValueMIPS_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [val])
for {
@@ -1170,7 +1170,7 @@
return true
}
}
-func rewriteValueMIPS_OpConst8_0(v *Value) bool {
+func rewriteValueMIPS_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVWconst [val])
for {
@@ -1180,7 +1180,7 @@
return true
}
}
-func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
+func rewriteValueMIPS_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVWconst [b])
for {
@@ -1190,7 +1190,7 @@
return true
}
}
-func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
+func rewriteValueMIPS_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVWconst [0])
for {
@@ -1199,7 +1199,7 @@
return true
}
}
-func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
+func rewriteValueMIPS_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1226,7 +1226,7 @@
return true
}
}
-func rewriteValueMIPS_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueMIPS_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (Ctz32 x)
@@ -1237,7 +1237,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (TRUNCFW x)
@@ -1248,7 +1248,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (MOVFD x)
@@ -1259,7 +1259,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (MOVWF x)
@@ -1270,7 +1270,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (MOVWD x)
@@ -1281,7 +1281,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (TRUNCDW x)
@@ -1292,7 +1292,7 @@
return true
}
}
-func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (MOVDF x)
@@ -1303,7 +1303,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1325,7 +1325,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1347,7 +1347,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1365,7 +1365,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1379,7 +1379,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1397,7 +1397,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1411,7 +1411,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1433,7 +1433,7 @@
return true
}
}
-func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
+func rewriteValueMIPS_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1455,7 +1455,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq16_0(v *Value) bool {
+func rewriteValueMIPS_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1478,7 +1478,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq32_0(v *Value) bool {
+func rewriteValueMIPS_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1497,7 +1497,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1514,7 +1514,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1531,7 +1531,7 @@
return true
}
}
-func rewriteValueMIPS_OpEq8_0(v *Value) bool {
+func rewriteValueMIPS_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1554,7 +1554,7 @@
return true
}
}
-func rewriteValueMIPS_OpEqB_0(v *Value) bool {
+func rewriteValueMIPS_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1573,7 +1573,7 @@
return true
}
}
-func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1592,7 +1592,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1615,7 +1615,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1638,7 +1638,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1657,7 +1657,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1674,7 +1674,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1693,7 +1693,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1710,7 +1710,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1733,7 +1733,7 @@
return true
}
}
-func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
+func rewriteValueMIPS_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1756,7 +1756,7 @@
return true
}
}
-func rewriteValueMIPS_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueMIPS_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -1764,7 +1764,7 @@
return true
}
}
-func rewriteValueMIPS_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueMIPS_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -1772,7 +1772,7 @@
return true
}
}
-func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -1780,7 +1780,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1800,7 +1800,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1820,7 +1820,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32 x y)
@@ -1834,7 +1834,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1851,7 +1851,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32U x y)
@@ -1865,7 +1865,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1882,7 +1882,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1902,7 +1902,7 @@
return true
}
}
-func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
+func rewriteValueMIPS_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1922,7 +1922,7 @@
return true
}
}
-func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
+func rewriteValueMIPS_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1940,7 +1940,7 @@
return true
}
}
-func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
+func rewriteValueMIPS_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1958,7 +1958,7 @@
return true
}
}
-func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
+func rewriteValueMIPS_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -1974,7 +1974,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -1988,7 +1988,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
+func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2004,7 +2004,7 @@
return true
}
}
-func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2023,7 +2023,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2046,7 +2046,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2069,7 +2069,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2088,7 +2088,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2105,7 +2105,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2124,7 +2124,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2141,7 +2141,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2164,7 +2164,7 @@
return true
}
}
-func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
+func rewriteValueMIPS_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2187,7 +2187,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess16_0(v *Value) bool {
+func rewriteValueMIPS_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2207,7 +2207,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2227,7 +2227,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32 x y)
@@ -2241,7 +2241,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2258,7 +2258,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32U x y)
@@ -2272,7 +2272,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
+func rewriteValueMIPS_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2289,7 +2289,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess8_0(v *Value) bool {
+func rewriteValueMIPS_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2309,7 +2309,7 @@
return true
}
}
-func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
+func rewriteValueMIPS_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2329,7 +2329,7 @@
return true
}
}
-func rewriteValueMIPS_OpLoad_0(v *Value) bool {
+func rewriteValueMIPS_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2454,7 +2454,7 @@
}
return false
}
-func rewriteValueMIPS_OpLocalAddr_0(v *Value) bool {
+func rewriteValueMIPS_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVWaddr {sym} base)
@@ -2467,7 +2467,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2497,7 +2497,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2523,7 +2523,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x (Const64 [c]))
@@ -2560,7 +2560,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2590,7 +2590,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2620,7 +2620,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2646,7 +2646,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x (Const64 [c]))
@@ -2683,7 +2683,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2713,7 +2713,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2743,7 +2743,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2769,7 +2769,7 @@
return true
}
}
-func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x (Const64 [c]))
@@ -2806,7 +2806,7 @@
}
return false
}
-func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2836,7 +2836,7 @@
return true
}
}
-func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD x (MOVWconst [c]))
@@ -2873,7 +2873,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// result: (MOVWaddr [off1+off2] {sym} ptr)
@@ -2945,7 +2945,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3001,7 +3001,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVWconst [0])
@@ -3053,7 +3053,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3101,7 +3101,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CMOVZzero _ (MOVWconst [0]))
@@ -3133,7 +3133,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3158,7 +3158,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3177,7 +3177,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3250,7 +3250,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBUreg x:(MOVBUload _ _))
@@ -3328,7 +3328,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3401,7 +3401,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVBreg x:(MOVBload _ _))
@@ -3483,7 +3483,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3651,7 +3651,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3702,7 +3702,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3776,7 +3776,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3832,7 +3832,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -3906,7 +3906,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3962,7 +3962,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4035,7 +4035,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHUreg x:(MOVBUload _ _))
@@ -4136,7 +4136,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4209,7 +4209,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MOVHreg x:(MOVBload _ _))
@@ -4337,7 +4337,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4467,7 +4467,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4518,7 +4518,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4592,7 +4592,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x)
// cond: x.Uses == 1
@@ -4619,7 +4619,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4711,7 +4711,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
@@ -4762,7 +4762,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MUL (MOVWconst [0]) _ )
@@ -4847,7 +4847,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
v_0 := v.Args[0]
// match: (NEG (MOVWconst [c]))
// result: (MOVWconst [int64(int32(-c))])
@@ -4862,7 +4862,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NOR x (MOVWconst [c]))
@@ -4883,7 +4883,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (NORconst [c] (MOVWconst [d]))
// result: (MOVWconst [^(c|d)])
@@ -4899,7 +4899,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4954,7 +4954,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -5006,7 +5006,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGT (MOVWconst [c]) x)
@@ -5035,7 +5035,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGTU (MOVWconst [c]) x)
@@ -5064,7 +5064,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTUconst [c] (MOVWconst [d]))
// cond: uint32(c)>uint32(d)
@@ -5156,7 +5156,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTUzero (MOVWconst [d]))
// cond: uint32(d) != 0
@@ -5190,7 +5190,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTconst [c] (MOVWconst [d]))
// cond: int32(c) > int32(d)
@@ -5320,10 +5320,6 @@
v.AuxInt = 0
return true
}
- return false
-}
-func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (SGTconst [c] (ANDconst [m] _))
// cond: 0 <= int32(m) && int32(m) < int32(c)
// result: (MOVWconst [1])
@@ -5358,7 +5354,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTzero (MOVWconst [d]))
// cond: int32(d) > 0
@@ -5392,7 +5388,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLL _ (MOVWconst [c]))
@@ -5425,7 +5421,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SLLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))])
@@ -5441,7 +5437,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRA x (MOVWconst [c]))
@@ -5476,7 +5472,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRAconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(int32(d)>>uint32(c))])
@@ -5492,7 +5488,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRL _ (MOVWconst [c]))
@@ -5525,7 +5521,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRLconst [c] (MOVWconst [d]))
// result: (MOVWconst [int64(uint32(d)>>uint32(c))])
@@ -5541,7 +5537,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB x (MOVWconst [c]))
@@ -5581,7 +5577,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -5637,7 +5633,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVWconst [c]))
@@ -5669,7 +5665,7 @@
}
return false
}
-func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -5723,7 +5719,7 @@
}
return false
}
-func rewriteValueMIPS_OpMod16_0(v *Value) bool {
+func rewriteValueMIPS_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5745,7 +5741,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5767,7 +5763,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod32_0(v *Value) bool {
+func rewriteValueMIPS_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5785,7 +5781,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5803,7 +5799,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod8_0(v *Value) bool {
+func rewriteValueMIPS_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5825,7 +5821,7 @@
return true
}
}
-func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
+func rewriteValueMIPS_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5847,11 +5843,12 @@
return true
}
}
-func rewriteValueMIPS_OpMove_0(v *Value) bool {
+func rewriteValueMIPS_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Move [0] _ _ mem)
// result: mem
@@ -6151,15 +6148,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueMIPS_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Move [6] {t} dst src mem)
// cond: t.(*types.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)))
@@ -6317,7 +6305,7 @@
}
return false
}
-func rewriteValueMIPS_OpMul16_0(v *Value) bool {
+func rewriteValueMIPS_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -6331,7 +6319,7 @@
return true
}
}
-func rewriteValueMIPS_OpMul32_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -6345,7 +6333,7 @@
return true
}
}
-func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -6359,7 +6347,7 @@
return true
}
}
-func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
+func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32uhilo x y)
@@ -6373,7 +6361,7 @@
return true
}
}
-func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
+func rewriteValueMIPS_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -6387,7 +6375,7 @@
return true
}
}
-func rewriteValueMIPS_OpMul8_0(v *Value) bool {
+func rewriteValueMIPS_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -6401,7 +6389,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEG x)
@@ -6412,7 +6400,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEG x)
@@ -6423,7 +6411,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (NEGF x)
@@ -6434,7 +6422,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (NEGD x)
@@ -6445,7 +6433,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
+func rewriteValueMIPS_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEG x)
@@ -6456,7 +6444,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6481,7 +6469,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6502,7 +6490,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6519,7 +6507,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6536,7 +6524,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
+func rewriteValueMIPS_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6561,7 +6549,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
+func rewriteValueMIPS_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -6575,7 +6563,7 @@
return true
}
}
-func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6596,7 +6584,7 @@
return true
}
}
-func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
+func rewriteValueMIPS_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -6610,7 +6598,7 @@
return true
}
}
-func rewriteValueMIPS_OpNot_0(v *Value) bool {
+func rewriteValueMIPS_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -6622,7 +6610,7 @@
return true
}
}
-func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVWaddr [off] ptr)
@@ -6648,7 +6636,7 @@
return true
}
}
-func rewriteValueMIPS_OpOr16_0(v *Value) bool {
+func rewriteValueMIPS_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -6662,7 +6650,7 @@
return true
}
}
-func rewriteValueMIPS_OpOr32_0(v *Value) bool {
+func rewriteValueMIPS_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -6676,7 +6664,7 @@
return true
}
}
-func rewriteValueMIPS_OpOr8_0(v *Value) bool {
+func rewriteValueMIPS_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -6690,7 +6678,7 @@
return true
}
}
-func rewriteValueMIPS_OpOrB_0(v *Value) bool {
+func rewriteValueMIPS_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -6704,7 +6692,7 @@
return true
}
}
-func rewriteValueMIPS_OpPanicBounds_0(v *Value) bool {
+func rewriteValueMIPS_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6764,7 +6752,7 @@
}
return false
}
-func rewriteValueMIPS_OpPanicExtend_0(v *Value) bool {
+func rewriteValueMIPS_OpPanicExtend(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -6831,7 +6819,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6862,7 +6850,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6893,7 +6881,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6924,7 +6912,7 @@
}
return false
}
-func rewriteValueMIPS_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueMIPS_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6955,7 +6943,7 @@
}
return false
}
-func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
+func rewriteValueMIPS_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -6967,7 +6955,7 @@
return true
}
}
-func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
+func rewriteValueMIPS_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -6979,7 +6967,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7011,7 +6999,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7039,7 +7027,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7081,7 +7069,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7113,7 +7101,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7144,7 +7132,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7171,7 +7159,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7218,7 +7206,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7249,7 +7237,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7279,7 +7267,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7305,7 +7293,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32Ux64 x (Const64 [c]))
@@ -7342,7 +7330,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7372,7 +7360,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7401,7 +7389,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7426,7 +7414,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Rsh32x64 x (Const64 [c]))
@@ -7465,7 +7453,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7494,7 +7482,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7526,7 +7514,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7554,7 +7542,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7596,7 +7584,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7628,7 +7616,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7659,7 +7647,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7686,7 +7674,7 @@
return true
}
}
-func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7733,7 +7721,7 @@
}
return false
}
-func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7764,7 +7752,7 @@
return true
}
}
-func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
+func rewriteValueMIPS_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7957,7 +7945,7 @@
}
return false
}
-func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
+func rewriteValueMIPS_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8152,7 +8140,7 @@
}
return false
}
-func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -8163,7 +8151,7 @@
return true
}
}
-func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -8174,7 +8162,7 @@
return true
}
}
-func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -8185,7 +8173,7 @@
return true
}
}
-func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
+func rewriteValueMIPS_OpSignmask(v *Value) bool {
v_0 := v.Args[0]
// match: (Signmask x)
// result: (SRAconst x [31])
@@ -8197,7 +8185,7 @@
return true
}
}
-func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
+func rewriteValueMIPS_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -8213,7 +8201,7 @@
return true
}
}
-func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
+func rewriteValueMIPS_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (SQRTD x)
@@ -8224,7 +8212,7 @@
return true
}
}
-func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
+func rewriteValueMIPS_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -8239,7 +8227,7 @@
return true
}
}
-func rewriteValueMIPS_OpStore_0(v *Value) bool {
+func rewriteValueMIPS_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8330,7 +8318,7 @@
}
return false
}
-func rewriteValueMIPS_OpSub16_0(v *Value) bool {
+func rewriteValueMIPS_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -8344,7 +8332,7 @@
return true
}
}
-func rewriteValueMIPS_OpSub32_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -8358,7 +8346,7 @@
return true
}
}
-func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -8372,7 +8360,7 @@
return true
}
}
-func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
+func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8393,7 +8381,7 @@
return true
}
}
-func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
+func rewriteValueMIPS_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -8407,7 +8395,7 @@
return true
}
}
-func rewriteValueMIPS_OpSub8_0(v *Value) bool {
+func rewriteValueMIPS_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -8421,7 +8409,7 @@
return true
}
}
-func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
+func rewriteValueMIPS_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -8435,7 +8423,7 @@
return true
}
}
-func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -8447,7 +8435,7 @@
return true
}
}
-func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -8459,7 +8447,7 @@
return true
}
}
-func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -8471,7 +8459,7 @@
return true
}
}
-func rewriteValueMIPS_OpWB_0(v *Value) bool {
+func rewriteValueMIPS_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8490,7 +8478,7 @@
return true
}
}
-func rewriteValueMIPS_OpXor16_0(v *Value) bool {
+func rewriteValueMIPS_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -8504,7 +8492,7 @@
return true
}
}
-func rewriteValueMIPS_OpXor32_0(v *Value) bool {
+func rewriteValueMIPS_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -8518,7 +8506,7 @@
return true
}
}
-func rewriteValueMIPS_OpXor8_0(v *Value) bool {
+func rewriteValueMIPS_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -8532,10 +8520,11 @@
return true
}
}
-func rewriteValueMIPS_OpZero_0(v *Value) bool {
+func rewriteValueMIPS_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Zero [0] _ mem)
// result: mem
@@ -8794,14 +8783,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueMIPS_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Zero [12] {t} ptr mem)
// cond: t.(*types.Type).Alignment()%4 == 0
// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem)))
@@ -8904,7 +8885,7 @@
}
return false
}
-func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHUreg x)
@@ -8915,7 +8896,7 @@
return true
}
}
-func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBUreg x)
@@ -8926,7 +8907,7 @@
return true
}
}
-func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBUreg x)
@@ -8937,7 +8918,7 @@
return true
}
}
-func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
+func rewriteValueMIPS_OpZeromask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
index 7657eef..58d5567 100644
--- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go
+++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go
@@ -8,619 +8,619 @@
func rewriteValueMIPS64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS64_OpAdd16_0(v)
+ return rewriteValueMIPS64_OpAdd16(v)
case OpAdd32:
- return rewriteValueMIPS64_OpAdd32_0(v)
+ return rewriteValueMIPS64_OpAdd32(v)
case OpAdd32F:
- return rewriteValueMIPS64_OpAdd32F_0(v)
+ return rewriteValueMIPS64_OpAdd32F(v)
case OpAdd64:
- return rewriteValueMIPS64_OpAdd64_0(v)
+ return rewriteValueMIPS64_OpAdd64(v)
case OpAdd64F:
- return rewriteValueMIPS64_OpAdd64F_0(v)
+ return rewriteValueMIPS64_OpAdd64F(v)
case OpAdd8:
- return rewriteValueMIPS64_OpAdd8_0(v)
+ return rewriteValueMIPS64_OpAdd8(v)
case OpAddPtr:
- return rewriteValueMIPS64_OpAddPtr_0(v)
+ return rewriteValueMIPS64_OpAddPtr(v)
case OpAddr:
- return rewriteValueMIPS64_OpAddr_0(v)
+ return rewriteValueMIPS64_OpAddr(v)
case OpAnd16:
- return rewriteValueMIPS64_OpAnd16_0(v)
+ return rewriteValueMIPS64_OpAnd16(v)
case OpAnd32:
- return rewriteValueMIPS64_OpAnd32_0(v)
+ return rewriteValueMIPS64_OpAnd32(v)
case OpAnd64:
- return rewriteValueMIPS64_OpAnd64_0(v)
+ return rewriteValueMIPS64_OpAnd64(v)
case OpAnd8:
- return rewriteValueMIPS64_OpAnd8_0(v)
+ return rewriteValueMIPS64_OpAnd8(v)
case OpAndB:
- return rewriteValueMIPS64_OpAndB_0(v)
+ return rewriteValueMIPS64_OpAndB(v)
case OpAtomicAdd32:
- return rewriteValueMIPS64_OpAtomicAdd32_0(v)
+ return rewriteValueMIPS64_OpAtomicAdd32(v)
case OpAtomicAdd64:
- return rewriteValueMIPS64_OpAtomicAdd64_0(v)
+ return rewriteValueMIPS64_OpAtomicAdd64(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueMIPS64_OpAtomicCompareAndSwap32_0(v)
+ return rewriteValueMIPS64_OpAtomicCompareAndSwap32(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueMIPS64_OpAtomicCompareAndSwap64_0(v)
+ return rewriteValueMIPS64_OpAtomicCompareAndSwap64(v)
case OpAtomicExchange32:
- return rewriteValueMIPS64_OpAtomicExchange32_0(v)
+ return rewriteValueMIPS64_OpAtomicExchange32(v)
case OpAtomicExchange64:
- return rewriteValueMIPS64_OpAtomicExchange64_0(v)
+ return rewriteValueMIPS64_OpAtomicExchange64(v)
case OpAtomicLoad32:
- return rewriteValueMIPS64_OpAtomicLoad32_0(v)
+ return rewriteValueMIPS64_OpAtomicLoad32(v)
case OpAtomicLoad64:
- return rewriteValueMIPS64_OpAtomicLoad64_0(v)
+ return rewriteValueMIPS64_OpAtomicLoad64(v)
case OpAtomicLoad8:
- return rewriteValueMIPS64_OpAtomicLoad8_0(v)
+ return rewriteValueMIPS64_OpAtomicLoad8(v)
case OpAtomicLoadPtr:
- return rewriteValueMIPS64_OpAtomicLoadPtr_0(v)
+ return rewriteValueMIPS64_OpAtomicLoadPtr(v)
case OpAtomicStore32:
- return rewriteValueMIPS64_OpAtomicStore32_0(v)
+ return rewriteValueMIPS64_OpAtomicStore32(v)
case OpAtomicStore64:
- return rewriteValueMIPS64_OpAtomicStore64_0(v)
+ return rewriteValueMIPS64_OpAtomicStore64(v)
case OpAtomicStore8:
- return rewriteValueMIPS64_OpAtomicStore8_0(v)
+ return rewriteValueMIPS64_OpAtomicStore8(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueMIPS64_OpAtomicStorePtrNoWB_0(v)
+ return rewriteValueMIPS64_OpAtomicStorePtrNoWB(v)
case OpAvg64u:
- return rewriteValueMIPS64_OpAvg64u_0(v)
+ return rewriteValueMIPS64_OpAvg64u(v)
case OpClosureCall:
- return rewriteValueMIPS64_OpClosureCall_0(v)
+ return rewriteValueMIPS64_OpClosureCall(v)
case OpCom16:
- return rewriteValueMIPS64_OpCom16_0(v)
+ return rewriteValueMIPS64_OpCom16(v)
case OpCom32:
- return rewriteValueMIPS64_OpCom32_0(v)
+ return rewriteValueMIPS64_OpCom32(v)
case OpCom64:
- return rewriteValueMIPS64_OpCom64_0(v)
+ return rewriteValueMIPS64_OpCom64(v)
case OpCom8:
- return rewriteValueMIPS64_OpCom8_0(v)
+ return rewriteValueMIPS64_OpCom8(v)
case OpConst16:
- return rewriteValueMIPS64_OpConst16_0(v)
+ return rewriteValueMIPS64_OpConst16(v)
case OpConst32:
- return rewriteValueMIPS64_OpConst32_0(v)
+ return rewriteValueMIPS64_OpConst32(v)
case OpConst32F:
- return rewriteValueMIPS64_OpConst32F_0(v)
+ return rewriteValueMIPS64_OpConst32F(v)
case OpConst64:
- return rewriteValueMIPS64_OpConst64_0(v)
+ return rewriteValueMIPS64_OpConst64(v)
case OpConst64F:
- return rewriteValueMIPS64_OpConst64F_0(v)
+ return rewriteValueMIPS64_OpConst64F(v)
case OpConst8:
- return rewriteValueMIPS64_OpConst8_0(v)
+ return rewriteValueMIPS64_OpConst8(v)
case OpConstBool:
- return rewriteValueMIPS64_OpConstBool_0(v)
+ return rewriteValueMIPS64_OpConstBool(v)
case OpConstNil:
- return rewriteValueMIPS64_OpConstNil_0(v)
+ return rewriteValueMIPS64_OpConstNil(v)
case OpCvt32Fto32:
- return rewriteValueMIPS64_OpCvt32Fto32_0(v)
+ return rewriteValueMIPS64_OpCvt32Fto32(v)
case OpCvt32Fto64:
- return rewriteValueMIPS64_OpCvt32Fto64_0(v)
+ return rewriteValueMIPS64_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValueMIPS64_OpCvt32Fto64F_0(v)
+ return rewriteValueMIPS64_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValueMIPS64_OpCvt32to32F_0(v)
+ return rewriteValueMIPS64_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueMIPS64_OpCvt32to64F_0(v)
+ return rewriteValueMIPS64_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueMIPS64_OpCvt64Fto32_0(v)
+ return rewriteValueMIPS64_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueMIPS64_OpCvt64Fto32F_0(v)
+ return rewriteValueMIPS64_OpCvt64Fto32F(v)
case OpCvt64Fto64:
- return rewriteValueMIPS64_OpCvt64Fto64_0(v)
+ return rewriteValueMIPS64_OpCvt64Fto64(v)
case OpCvt64to32F:
- return rewriteValueMIPS64_OpCvt64to32F_0(v)
+ return rewriteValueMIPS64_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValueMIPS64_OpCvt64to64F_0(v)
+ return rewriteValueMIPS64_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValueMIPS64_OpDiv16_0(v)
+ return rewriteValueMIPS64_OpDiv16(v)
case OpDiv16u:
- return rewriteValueMIPS64_OpDiv16u_0(v)
+ return rewriteValueMIPS64_OpDiv16u(v)
case OpDiv32:
- return rewriteValueMIPS64_OpDiv32_0(v)
+ return rewriteValueMIPS64_OpDiv32(v)
case OpDiv32F:
- return rewriteValueMIPS64_OpDiv32F_0(v)
+ return rewriteValueMIPS64_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueMIPS64_OpDiv32u_0(v)
+ return rewriteValueMIPS64_OpDiv32u(v)
case OpDiv64:
- return rewriteValueMIPS64_OpDiv64_0(v)
+ return rewriteValueMIPS64_OpDiv64(v)
case OpDiv64F:
- return rewriteValueMIPS64_OpDiv64F_0(v)
+ return rewriteValueMIPS64_OpDiv64F(v)
case OpDiv64u:
- return rewriteValueMIPS64_OpDiv64u_0(v)
+ return rewriteValueMIPS64_OpDiv64u(v)
case OpDiv8:
- return rewriteValueMIPS64_OpDiv8_0(v)
+ return rewriteValueMIPS64_OpDiv8(v)
case OpDiv8u:
- return rewriteValueMIPS64_OpDiv8u_0(v)
+ return rewriteValueMIPS64_OpDiv8u(v)
case OpEq16:
- return rewriteValueMIPS64_OpEq16_0(v)
+ return rewriteValueMIPS64_OpEq16(v)
case OpEq32:
- return rewriteValueMIPS64_OpEq32_0(v)
+ return rewriteValueMIPS64_OpEq32(v)
case OpEq32F:
- return rewriteValueMIPS64_OpEq32F_0(v)
+ return rewriteValueMIPS64_OpEq32F(v)
case OpEq64:
- return rewriteValueMIPS64_OpEq64_0(v)
+ return rewriteValueMIPS64_OpEq64(v)
case OpEq64F:
- return rewriteValueMIPS64_OpEq64F_0(v)
+ return rewriteValueMIPS64_OpEq64F(v)
case OpEq8:
- return rewriteValueMIPS64_OpEq8_0(v)
+ return rewriteValueMIPS64_OpEq8(v)
case OpEqB:
- return rewriteValueMIPS64_OpEqB_0(v)
+ return rewriteValueMIPS64_OpEqB(v)
case OpEqPtr:
- return rewriteValueMIPS64_OpEqPtr_0(v)
+ return rewriteValueMIPS64_OpEqPtr(v)
case OpGeq16:
- return rewriteValueMIPS64_OpGeq16_0(v)
+ return rewriteValueMIPS64_OpGeq16(v)
case OpGeq16U:
- return rewriteValueMIPS64_OpGeq16U_0(v)
+ return rewriteValueMIPS64_OpGeq16U(v)
case OpGeq32:
- return rewriteValueMIPS64_OpGeq32_0(v)
+ return rewriteValueMIPS64_OpGeq32(v)
case OpGeq32F:
- return rewriteValueMIPS64_OpGeq32F_0(v)
+ return rewriteValueMIPS64_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueMIPS64_OpGeq32U_0(v)
+ return rewriteValueMIPS64_OpGeq32U(v)
case OpGeq64:
- return rewriteValueMIPS64_OpGeq64_0(v)
+ return rewriteValueMIPS64_OpGeq64(v)
case OpGeq64F:
- return rewriteValueMIPS64_OpGeq64F_0(v)
+ return rewriteValueMIPS64_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueMIPS64_OpGeq64U_0(v)
+ return rewriteValueMIPS64_OpGeq64U(v)
case OpGeq8:
- return rewriteValueMIPS64_OpGeq8_0(v)
+ return rewriteValueMIPS64_OpGeq8(v)
case OpGeq8U:
- return rewriteValueMIPS64_OpGeq8U_0(v)
+ return rewriteValueMIPS64_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueMIPS64_OpGetCallerPC_0(v)
+ return rewriteValueMIPS64_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueMIPS64_OpGetCallerSP_0(v)
+ return rewriteValueMIPS64_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueMIPS64_OpGetClosurePtr_0(v)
+ return rewriteValueMIPS64_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueMIPS64_OpGreater16_0(v)
+ return rewriteValueMIPS64_OpGreater16(v)
case OpGreater16U:
- return rewriteValueMIPS64_OpGreater16U_0(v)
+ return rewriteValueMIPS64_OpGreater16U(v)
case OpGreater32:
- return rewriteValueMIPS64_OpGreater32_0(v)
+ return rewriteValueMIPS64_OpGreater32(v)
case OpGreater32F:
- return rewriteValueMIPS64_OpGreater32F_0(v)
+ return rewriteValueMIPS64_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueMIPS64_OpGreater32U_0(v)
+ return rewriteValueMIPS64_OpGreater32U(v)
case OpGreater64:
- return rewriteValueMIPS64_OpGreater64_0(v)
+ return rewriteValueMIPS64_OpGreater64(v)
case OpGreater64F:
- return rewriteValueMIPS64_OpGreater64F_0(v)
+ return rewriteValueMIPS64_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueMIPS64_OpGreater64U_0(v)
+ return rewriteValueMIPS64_OpGreater64U(v)
case OpGreater8:
- return rewriteValueMIPS64_OpGreater8_0(v)
+ return rewriteValueMIPS64_OpGreater8(v)
case OpGreater8U:
- return rewriteValueMIPS64_OpGreater8U_0(v)
+ return rewriteValueMIPS64_OpGreater8U(v)
case OpHmul32:
- return rewriteValueMIPS64_OpHmul32_0(v)
+ return rewriteValueMIPS64_OpHmul32(v)
case OpHmul32u:
- return rewriteValueMIPS64_OpHmul32u_0(v)
+ return rewriteValueMIPS64_OpHmul32u(v)
case OpHmul64:
- return rewriteValueMIPS64_OpHmul64_0(v)
+ return rewriteValueMIPS64_OpHmul64(v)
case OpHmul64u:
- return rewriteValueMIPS64_OpHmul64u_0(v)
+ return rewriteValueMIPS64_OpHmul64u(v)
case OpInterCall:
- return rewriteValueMIPS64_OpInterCall_0(v)
+ return rewriteValueMIPS64_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueMIPS64_OpIsInBounds_0(v)
+ return rewriteValueMIPS64_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueMIPS64_OpIsNonNil_0(v)
+ return rewriteValueMIPS64_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueMIPS64_OpIsSliceInBounds_0(v)
+ return rewriteValueMIPS64_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueMIPS64_OpLeq16_0(v)
+ return rewriteValueMIPS64_OpLeq16(v)
case OpLeq16U:
- return rewriteValueMIPS64_OpLeq16U_0(v)
+ return rewriteValueMIPS64_OpLeq16U(v)
case OpLeq32:
- return rewriteValueMIPS64_OpLeq32_0(v)
+ return rewriteValueMIPS64_OpLeq32(v)
case OpLeq32F:
- return rewriteValueMIPS64_OpLeq32F_0(v)
+ return rewriteValueMIPS64_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueMIPS64_OpLeq32U_0(v)
+ return rewriteValueMIPS64_OpLeq32U(v)
case OpLeq64:
- return rewriteValueMIPS64_OpLeq64_0(v)
+ return rewriteValueMIPS64_OpLeq64(v)
case OpLeq64F:
- return rewriteValueMIPS64_OpLeq64F_0(v)
+ return rewriteValueMIPS64_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueMIPS64_OpLeq64U_0(v)
+ return rewriteValueMIPS64_OpLeq64U(v)
case OpLeq8:
- return rewriteValueMIPS64_OpLeq8_0(v)
+ return rewriteValueMIPS64_OpLeq8(v)
case OpLeq8U:
- return rewriteValueMIPS64_OpLeq8U_0(v)
+ return rewriteValueMIPS64_OpLeq8U(v)
case OpLess16:
- return rewriteValueMIPS64_OpLess16_0(v)
+ return rewriteValueMIPS64_OpLess16(v)
case OpLess16U:
- return rewriteValueMIPS64_OpLess16U_0(v)
+ return rewriteValueMIPS64_OpLess16U(v)
case OpLess32:
- return rewriteValueMIPS64_OpLess32_0(v)
+ return rewriteValueMIPS64_OpLess32(v)
case OpLess32F:
- return rewriteValueMIPS64_OpLess32F_0(v)
+ return rewriteValueMIPS64_OpLess32F(v)
case OpLess32U:
- return rewriteValueMIPS64_OpLess32U_0(v)
+ return rewriteValueMIPS64_OpLess32U(v)
case OpLess64:
- return rewriteValueMIPS64_OpLess64_0(v)
+ return rewriteValueMIPS64_OpLess64(v)
case OpLess64F:
- return rewriteValueMIPS64_OpLess64F_0(v)
+ return rewriteValueMIPS64_OpLess64F(v)
case OpLess64U:
- return rewriteValueMIPS64_OpLess64U_0(v)
+ return rewriteValueMIPS64_OpLess64U(v)
case OpLess8:
- return rewriteValueMIPS64_OpLess8_0(v)
+ return rewriteValueMIPS64_OpLess8(v)
case OpLess8U:
- return rewriteValueMIPS64_OpLess8U_0(v)
+ return rewriteValueMIPS64_OpLess8U(v)
case OpLoad:
- return rewriteValueMIPS64_OpLoad_0(v)
+ return rewriteValueMIPS64_OpLoad(v)
case OpLocalAddr:
- return rewriteValueMIPS64_OpLocalAddr_0(v)
+ return rewriteValueMIPS64_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueMIPS64_OpLsh16x16_0(v)
+ return rewriteValueMIPS64_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueMIPS64_OpLsh16x32_0(v)
+ return rewriteValueMIPS64_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueMIPS64_OpLsh16x64_0(v)
+ return rewriteValueMIPS64_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueMIPS64_OpLsh16x8_0(v)
+ return rewriteValueMIPS64_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueMIPS64_OpLsh32x16_0(v)
+ return rewriteValueMIPS64_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueMIPS64_OpLsh32x32_0(v)
+ return rewriteValueMIPS64_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueMIPS64_OpLsh32x64_0(v)
+ return rewriteValueMIPS64_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueMIPS64_OpLsh32x8_0(v)
+ return rewriteValueMIPS64_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueMIPS64_OpLsh64x16_0(v)
+ return rewriteValueMIPS64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueMIPS64_OpLsh64x32_0(v)
+ return rewriteValueMIPS64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueMIPS64_OpLsh64x64_0(v)
+ return rewriteValueMIPS64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueMIPS64_OpLsh64x8_0(v)
+ return rewriteValueMIPS64_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueMIPS64_OpLsh8x16_0(v)
+ return rewriteValueMIPS64_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueMIPS64_OpLsh8x32_0(v)
+ return rewriteValueMIPS64_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueMIPS64_OpLsh8x64_0(v)
+ return rewriteValueMIPS64_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueMIPS64_OpLsh8x8_0(v)
+ return rewriteValueMIPS64_OpLsh8x8(v)
case OpMIPS64ADDV:
- return rewriteValueMIPS64_OpMIPS64ADDV_0(v)
+ return rewriteValueMIPS64_OpMIPS64ADDV(v)
case OpMIPS64ADDVconst:
- return rewriteValueMIPS64_OpMIPS64ADDVconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64ADDVconst(v)
case OpMIPS64AND:
- return rewriteValueMIPS64_OpMIPS64AND_0(v)
+ return rewriteValueMIPS64_OpMIPS64AND(v)
case OpMIPS64ANDconst:
- return rewriteValueMIPS64_OpMIPS64ANDconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64ANDconst(v)
case OpMIPS64LoweredAtomicAdd32:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32_0(v)
+ return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32(v)
case OpMIPS64LoweredAtomicAdd64:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64_0(v)
+ return rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64(v)
case OpMIPS64LoweredAtomicStore32:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32_0(v)
+ return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32(v)
case OpMIPS64LoweredAtomicStore64:
- return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64_0(v)
+ return rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64(v)
case OpMIPS64MOVBUload:
- return rewriteValueMIPS64_OpMIPS64MOVBUload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUload(v)
case OpMIPS64MOVBUreg:
- return rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUreg(v)
case OpMIPS64MOVBload:
- return rewriteValueMIPS64_OpMIPS64MOVBload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBload(v)
case OpMIPS64MOVBreg:
- return rewriteValueMIPS64_OpMIPS64MOVBreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBreg(v)
case OpMIPS64MOVBstore:
- return rewriteValueMIPS64_OpMIPS64MOVBstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstore(v)
case OpMIPS64MOVBstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v)
case OpMIPS64MOVDload:
- return rewriteValueMIPS64_OpMIPS64MOVDload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDload(v)
case OpMIPS64MOVDstore:
- return rewriteValueMIPS64_OpMIPS64MOVDstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDstore(v)
case OpMIPS64MOVFload:
- return rewriteValueMIPS64_OpMIPS64MOVFload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFload(v)
case OpMIPS64MOVFstore:
- return rewriteValueMIPS64_OpMIPS64MOVFstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFstore(v)
case OpMIPS64MOVHUload:
- return rewriteValueMIPS64_OpMIPS64MOVHUload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUload(v)
case OpMIPS64MOVHUreg:
- return rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUreg(v)
case OpMIPS64MOVHload:
- return rewriteValueMIPS64_OpMIPS64MOVHload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHload(v)
case OpMIPS64MOVHreg:
- return rewriteValueMIPS64_OpMIPS64MOVHreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHreg(v)
case OpMIPS64MOVHstore:
- return rewriteValueMIPS64_OpMIPS64MOVHstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstore(v)
case OpMIPS64MOVHstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v)
case OpMIPS64MOVVload:
- return rewriteValueMIPS64_OpMIPS64MOVVload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVload(v)
case OpMIPS64MOVVreg:
- return rewriteValueMIPS64_OpMIPS64MOVVreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
case OpMIPS64MOVVstore:
- return rewriteValueMIPS64_OpMIPS64MOVVstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstore(v)
case OpMIPS64MOVVstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v)
case OpMIPS64MOVWUload:
- return rewriteValueMIPS64_OpMIPS64MOVWUload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUload(v)
case OpMIPS64MOVWUreg:
- return rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUreg(v)
case OpMIPS64MOVWload:
- return rewriteValueMIPS64_OpMIPS64MOVWload_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWload(v)
case OpMIPS64MOVWreg:
- return rewriteValueMIPS64_OpMIPS64MOVWreg_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWreg(v)
case OpMIPS64MOVWstore:
- return rewriteValueMIPS64_OpMIPS64MOVWstore_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstore(v)
case OpMIPS64MOVWstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v)
case OpMIPS64NEGV:
- return rewriteValueMIPS64_OpMIPS64NEGV_0(v)
+ return rewriteValueMIPS64_OpMIPS64NEGV(v)
case OpMIPS64NOR:
- return rewriteValueMIPS64_OpMIPS64NOR_0(v)
+ return rewriteValueMIPS64_OpMIPS64NOR(v)
case OpMIPS64NORconst:
- return rewriteValueMIPS64_OpMIPS64NORconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64NORconst(v)
case OpMIPS64OR:
- return rewriteValueMIPS64_OpMIPS64OR_0(v)
+ return rewriteValueMIPS64_OpMIPS64OR(v)
case OpMIPS64ORconst:
- return rewriteValueMIPS64_OpMIPS64ORconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64ORconst(v)
case OpMIPS64SGT:
- return rewriteValueMIPS64_OpMIPS64SGT_0(v)
+ return rewriteValueMIPS64_OpMIPS64SGT(v)
case OpMIPS64SGTU:
- return rewriteValueMIPS64_OpMIPS64SGTU_0(v)
+ return rewriteValueMIPS64_OpMIPS64SGTU(v)
case OpMIPS64SGTUconst:
- return rewriteValueMIPS64_OpMIPS64SGTUconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64SGTUconst(v)
case OpMIPS64SGTconst:
- return rewriteValueMIPS64_OpMIPS64SGTconst_0(v) || rewriteValueMIPS64_OpMIPS64SGTconst_10(v)
+ return rewriteValueMIPS64_OpMIPS64SGTconst(v)
case OpMIPS64SLLV:
- return rewriteValueMIPS64_OpMIPS64SLLV_0(v)
+ return rewriteValueMIPS64_OpMIPS64SLLV(v)
case OpMIPS64SLLVconst:
- return rewriteValueMIPS64_OpMIPS64SLLVconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64SLLVconst(v)
case OpMIPS64SRAV:
- return rewriteValueMIPS64_OpMIPS64SRAV_0(v)
+ return rewriteValueMIPS64_OpMIPS64SRAV(v)
case OpMIPS64SRAVconst:
- return rewriteValueMIPS64_OpMIPS64SRAVconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64SRAVconst(v)
case OpMIPS64SRLV:
- return rewriteValueMIPS64_OpMIPS64SRLV_0(v)
+ return rewriteValueMIPS64_OpMIPS64SRLV(v)
case OpMIPS64SRLVconst:
- return rewriteValueMIPS64_OpMIPS64SRLVconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64SRLVconst(v)
case OpMIPS64SUBV:
- return rewriteValueMIPS64_OpMIPS64SUBV_0(v)
+ return rewriteValueMIPS64_OpMIPS64SUBV(v)
case OpMIPS64SUBVconst:
- return rewriteValueMIPS64_OpMIPS64SUBVconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64SUBVconst(v)
case OpMIPS64XOR:
- return rewriteValueMIPS64_OpMIPS64XOR_0(v)
+ return rewriteValueMIPS64_OpMIPS64XOR(v)
case OpMIPS64XORconst:
- return rewriteValueMIPS64_OpMIPS64XORconst_0(v)
+ return rewriteValueMIPS64_OpMIPS64XORconst(v)
case OpMod16:
- return rewriteValueMIPS64_OpMod16_0(v)
+ return rewriteValueMIPS64_OpMod16(v)
case OpMod16u:
- return rewriteValueMIPS64_OpMod16u_0(v)
+ return rewriteValueMIPS64_OpMod16u(v)
case OpMod32:
- return rewriteValueMIPS64_OpMod32_0(v)
+ return rewriteValueMIPS64_OpMod32(v)
case OpMod32u:
- return rewriteValueMIPS64_OpMod32u_0(v)
+ return rewriteValueMIPS64_OpMod32u(v)
case OpMod64:
- return rewriteValueMIPS64_OpMod64_0(v)
+ return rewriteValueMIPS64_OpMod64(v)
case OpMod64u:
- return rewriteValueMIPS64_OpMod64u_0(v)
+ return rewriteValueMIPS64_OpMod64u(v)
case OpMod8:
- return rewriteValueMIPS64_OpMod8_0(v)
+ return rewriteValueMIPS64_OpMod8(v)
case OpMod8u:
- return rewriteValueMIPS64_OpMod8u_0(v)
+ return rewriteValueMIPS64_OpMod8u(v)
case OpMove:
- return rewriteValueMIPS64_OpMove_0(v) || rewriteValueMIPS64_OpMove_10(v)
+ return rewriteValueMIPS64_OpMove(v)
case OpMul16:
- return rewriteValueMIPS64_OpMul16_0(v)
+ return rewriteValueMIPS64_OpMul16(v)
case OpMul32:
- return rewriteValueMIPS64_OpMul32_0(v)
+ return rewriteValueMIPS64_OpMul32(v)
case OpMul32F:
- return rewriteValueMIPS64_OpMul32F_0(v)
+ return rewriteValueMIPS64_OpMul32F(v)
case OpMul64:
- return rewriteValueMIPS64_OpMul64_0(v)
+ return rewriteValueMIPS64_OpMul64(v)
case OpMul64F:
- return rewriteValueMIPS64_OpMul64F_0(v)
+ return rewriteValueMIPS64_OpMul64F(v)
case OpMul64uhilo:
- return rewriteValueMIPS64_OpMul64uhilo_0(v)
+ return rewriteValueMIPS64_OpMul64uhilo(v)
case OpMul8:
- return rewriteValueMIPS64_OpMul8_0(v)
+ return rewriteValueMIPS64_OpMul8(v)
case OpNeg16:
- return rewriteValueMIPS64_OpNeg16_0(v)
+ return rewriteValueMIPS64_OpNeg16(v)
case OpNeg32:
- return rewriteValueMIPS64_OpNeg32_0(v)
+ return rewriteValueMIPS64_OpNeg32(v)
case OpNeg32F:
- return rewriteValueMIPS64_OpNeg32F_0(v)
+ return rewriteValueMIPS64_OpNeg32F(v)
case OpNeg64:
- return rewriteValueMIPS64_OpNeg64_0(v)
+ return rewriteValueMIPS64_OpNeg64(v)
case OpNeg64F:
- return rewriteValueMIPS64_OpNeg64F_0(v)
+ return rewriteValueMIPS64_OpNeg64F(v)
case OpNeg8:
- return rewriteValueMIPS64_OpNeg8_0(v)
+ return rewriteValueMIPS64_OpNeg8(v)
case OpNeq16:
- return rewriteValueMIPS64_OpNeq16_0(v)
+ return rewriteValueMIPS64_OpNeq16(v)
case OpNeq32:
- return rewriteValueMIPS64_OpNeq32_0(v)
+ return rewriteValueMIPS64_OpNeq32(v)
case OpNeq32F:
- return rewriteValueMIPS64_OpNeq32F_0(v)
+ return rewriteValueMIPS64_OpNeq32F(v)
case OpNeq64:
- return rewriteValueMIPS64_OpNeq64_0(v)
+ return rewriteValueMIPS64_OpNeq64(v)
case OpNeq64F:
- return rewriteValueMIPS64_OpNeq64F_0(v)
+ return rewriteValueMIPS64_OpNeq64F(v)
case OpNeq8:
- return rewriteValueMIPS64_OpNeq8_0(v)
+ return rewriteValueMIPS64_OpNeq8(v)
case OpNeqB:
- return rewriteValueMIPS64_OpNeqB_0(v)
+ return rewriteValueMIPS64_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueMIPS64_OpNeqPtr_0(v)
+ return rewriteValueMIPS64_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueMIPS64_OpNilCheck_0(v)
+ return rewriteValueMIPS64_OpNilCheck(v)
case OpNot:
- return rewriteValueMIPS64_OpNot_0(v)
+ return rewriteValueMIPS64_OpNot(v)
case OpOffPtr:
- return rewriteValueMIPS64_OpOffPtr_0(v)
+ return rewriteValueMIPS64_OpOffPtr(v)
case OpOr16:
- return rewriteValueMIPS64_OpOr16_0(v)
+ return rewriteValueMIPS64_OpOr16(v)
case OpOr32:
- return rewriteValueMIPS64_OpOr32_0(v)
+ return rewriteValueMIPS64_OpOr32(v)
case OpOr64:
- return rewriteValueMIPS64_OpOr64_0(v)
+ return rewriteValueMIPS64_OpOr64(v)
case OpOr8:
- return rewriteValueMIPS64_OpOr8_0(v)
+ return rewriteValueMIPS64_OpOr8(v)
case OpOrB:
- return rewriteValueMIPS64_OpOrB_0(v)
+ return rewriteValueMIPS64_OpOrB(v)
case OpPanicBounds:
- return rewriteValueMIPS64_OpPanicBounds_0(v)
+ return rewriteValueMIPS64_OpPanicBounds(v)
case OpRotateLeft16:
- return rewriteValueMIPS64_OpRotateLeft16_0(v)
+ return rewriteValueMIPS64_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueMIPS64_OpRotateLeft32_0(v)
+ return rewriteValueMIPS64_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueMIPS64_OpRotateLeft64_0(v)
+ return rewriteValueMIPS64_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueMIPS64_OpRotateLeft8_0(v)
+ return rewriteValueMIPS64_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueMIPS64_OpRound32F_0(v)
+ return rewriteValueMIPS64_OpRound32F(v)
case OpRound64F:
- return rewriteValueMIPS64_OpRound64F_0(v)
+ return rewriteValueMIPS64_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValueMIPS64_OpRsh16Ux16_0(v)
+ return rewriteValueMIPS64_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueMIPS64_OpRsh16Ux32_0(v)
+ return rewriteValueMIPS64_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueMIPS64_OpRsh16Ux64_0(v)
+ return rewriteValueMIPS64_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueMIPS64_OpRsh16Ux8_0(v)
+ return rewriteValueMIPS64_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueMIPS64_OpRsh16x16_0(v)
+ return rewriteValueMIPS64_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueMIPS64_OpRsh16x32_0(v)
+ return rewriteValueMIPS64_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueMIPS64_OpRsh16x64_0(v)
+ return rewriteValueMIPS64_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueMIPS64_OpRsh16x8_0(v)
+ return rewriteValueMIPS64_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueMIPS64_OpRsh32Ux16_0(v)
+ return rewriteValueMIPS64_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueMIPS64_OpRsh32Ux32_0(v)
+ return rewriteValueMIPS64_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueMIPS64_OpRsh32Ux64_0(v)
+ return rewriteValueMIPS64_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueMIPS64_OpRsh32Ux8_0(v)
+ return rewriteValueMIPS64_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueMIPS64_OpRsh32x16_0(v)
+ return rewriteValueMIPS64_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueMIPS64_OpRsh32x32_0(v)
+ return rewriteValueMIPS64_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueMIPS64_OpRsh32x64_0(v)
+ return rewriteValueMIPS64_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueMIPS64_OpRsh32x8_0(v)
+ return rewriteValueMIPS64_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueMIPS64_OpRsh64Ux16_0(v)
+ return rewriteValueMIPS64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueMIPS64_OpRsh64Ux32_0(v)
+ return rewriteValueMIPS64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueMIPS64_OpRsh64Ux64_0(v)
+ return rewriteValueMIPS64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueMIPS64_OpRsh64Ux8_0(v)
+ return rewriteValueMIPS64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueMIPS64_OpRsh64x16_0(v)
+ return rewriteValueMIPS64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueMIPS64_OpRsh64x32_0(v)
+ return rewriteValueMIPS64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueMIPS64_OpRsh64x64_0(v)
+ return rewriteValueMIPS64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueMIPS64_OpRsh64x8_0(v)
+ return rewriteValueMIPS64_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueMIPS64_OpRsh8Ux16_0(v)
+ return rewriteValueMIPS64_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueMIPS64_OpRsh8Ux32_0(v)
+ return rewriteValueMIPS64_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueMIPS64_OpRsh8Ux64_0(v)
+ return rewriteValueMIPS64_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueMIPS64_OpRsh8Ux8_0(v)
+ return rewriteValueMIPS64_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueMIPS64_OpRsh8x16_0(v)
+ return rewriteValueMIPS64_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueMIPS64_OpRsh8x32_0(v)
+ return rewriteValueMIPS64_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueMIPS64_OpRsh8x64_0(v)
+ return rewriteValueMIPS64_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueMIPS64_OpRsh8x8_0(v)
+ return rewriteValueMIPS64_OpRsh8x8(v)
case OpSelect0:
- return rewriteValueMIPS64_OpSelect0_0(v)
+ return rewriteValueMIPS64_OpSelect0(v)
case OpSelect1:
- return rewriteValueMIPS64_OpSelect1_0(v)
+ return rewriteValueMIPS64_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueMIPS64_OpSignExt16to32_0(v)
+ return rewriteValueMIPS64_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValueMIPS64_OpSignExt16to64_0(v)
+ return rewriteValueMIPS64_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValueMIPS64_OpSignExt32to64_0(v)
+ return rewriteValueMIPS64_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValueMIPS64_OpSignExt8to16_0(v)
+ return rewriteValueMIPS64_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueMIPS64_OpSignExt8to32_0(v)
+ return rewriteValueMIPS64_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValueMIPS64_OpSignExt8to64_0(v)
+ return rewriteValueMIPS64_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValueMIPS64_OpSlicemask_0(v)
+ return rewriteValueMIPS64_OpSlicemask(v)
case OpSqrt:
- return rewriteValueMIPS64_OpSqrt_0(v)
+ return rewriteValueMIPS64_OpSqrt(v)
case OpStaticCall:
- return rewriteValueMIPS64_OpStaticCall_0(v)
+ return rewriteValueMIPS64_OpStaticCall(v)
case OpStore:
- return rewriteValueMIPS64_OpStore_0(v)
+ return rewriteValueMIPS64_OpStore(v)
case OpSub16:
- return rewriteValueMIPS64_OpSub16_0(v)
+ return rewriteValueMIPS64_OpSub16(v)
case OpSub32:
- return rewriteValueMIPS64_OpSub32_0(v)
+ return rewriteValueMIPS64_OpSub32(v)
case OpSub32F:
- return rewriteValueMIPS64_OpSub32F_0(v)
+ return rewriteValueMIPS64_OpSub32F(v)
case OpSub64:
- return rewriteValueMIPS64_OpSub64_0(v)
+ return rewriteValueMIPS64_OpSub64(v)
case OpSub64F:
- return rewriteValueMIPS64_OpSub64F_0(v)
+ return rewriteValueMIPS64_OpSub64F(v)
case OpSub8:
- return rewriteValueMIPS64_OpSub8_0(v)
+ return rewriteValueMIPS64_OpSub8(v)
case OpSubPtr:
- return rewriteValueMIPS64_OpSubPtr_0(v)
+ return rewriteValueMIPS64_OpSubPtr(v)
case OpTrunc16to8:
- return rewriteValueMIPS64_OpTrunc16to8_0(v)
+ return rewriteValueMIPS64_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueMIPS64_OpTrunc32to16_0(v)
+ return rewriteValueMIPS64_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueMIPS64_OpTrunc32to8_0(v)
+ return rewriteValueMIPS64_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValueMIPS64_OpTrunc64to16_0(v)
+ return rewriteValueMIPS64_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValueMIPS64_OpTrunc64to32_0(v)
+ return rewriteValueMIPS64_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValueMIPS64_OpTrunc64to8_0(v)
+ return rewriteValueMIPS64_OpTrunc64to8(v)
case OpWB:
- return rewriteValueMIPS64_OpWB_0(v)
+ return rewriteValueMIPS64_OpWB(v)
case OpXor16:
- return rewriteValueMIPS64_OpXor16_0(v)
+ return rewriteValueMIPS64_OpXor16(v)
case OpXor32:
- return rewriteValueMIPS64_OpXor32_0(v)
+ return rewriteValueMIPS64_OpXor32(v)
case OpXor64:
- return rewriteValueMIPS64_OpXor64_0(v)
+ return rewriteValueMIPS64_OpXor64(v)
case OpXor8:
- return rewriteValueMIPS64_OpXor8_0(v)
+ return rewriteValueMIPS64_OpXor8(v)
case OpZero:
- return rewriteValueMIPS64_OpZero_0(v) || rewriteValueMIPS64_OpZero_10(v)
+ return rewriteValueMIPS64_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueMIPS64_OpZeroExt16to32_0(v)
+ return rewriteValueMIPS64_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValueMIPS64_OpZeroExt16to64_0(v)
+ return rewriteValueMIPS64_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValueMIPS64_OpZeroExt32to64_0(v)
+ return rewriteValueMIPS64_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValueMIPS64_OpZeroExt8to16_0(v)
+ return rewriteValueMIPS64_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueMIPS64_OpZeroExt8to32_0(v)
+ return rewriteValueMIPS64_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValueMIPS64_OpZeroExt8to64_0(v)
+ return rewriteValueMIPS64_OpZeroExt8to64(v)
}
return false
}
-func rewriteValueMIPS64_OpAdd16_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -634,7 +634,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -648,7 +648,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -662,7 +662,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -676,7 +676,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -690,7 +690,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAdd8_0(v *Value) bool {
+func rewriteValueMIPS64_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -704,7 +704,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -718,7 +718,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAddr_0(v *Value) bool {
+func rewriteValueMIPS64_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVVaddr {sym} base)
@@ -731,7 +731,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd16_0(v *Value) bool {
+func rewriteValueMIPS64_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -745,7 +745,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -759,7 +759,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -773,7 +773,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAnd8_0(v *Value) bool {
+func rewriteValueMIPS64_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -787,7 +787,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAndB_0(v *Value) bool {
+func rewriteValueMIPS64_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -801,7 +801,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -818,7 +818,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicAdd64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -835,7 +835,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicCompareAndSwap32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -855,7 +855,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicCompareAndSwap64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicCompareAndSwap64(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -875,7 +875,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -892,7 +892,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicExchange64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicExchange64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -909,7 +909,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicLoad32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -923,7 +923,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicLoad64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicLoad64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -937,7 +937,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicLoad8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -951,7 +951,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicLoadPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -965,7 +965,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -982,7 +982,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicStore64_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -999,7 +999,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1016,7 +1016,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueMIPS64_OpAtomicStorePtrNoWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1033,7 +1033,7 @@
return true
}
}
-func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool {
+func rewriteValueMIPS64_OpAvg64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1055,7 +1055,7 @@
return true
}
}
-func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool {
+func rewriteValueMIPS64_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1074,7 +1074,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom16_0(v *Value) bool {
+func rewriteValueMIPS64_OpCom16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1090,7 +1090,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom32_0(v *Value) bool {
+func rewriteValueMIPS64_OpCom32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1106,7 +1106,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom64_0(v *Value) bool {
+func rewriteValueMIPS64_OpCom64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1122,7 +1122,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCom8_0(v *Value) bool {
+func rewriteValueMIPS64_OpCom8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1138,7 +1138,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst16_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVVconst [val])
for {
@@ -1148,7 +1148,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVVconst [val])
for {
@@ -1158,7 +1158,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (MOVFconst [val])
for {
@@ -1168,7 +1168,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (MOVVconst [val])
for {
@@ -1178,7 +1178,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (MOVDconst [val])
for {
@@ -1188,7 +1188,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConst8_0(v *Value) bool {
+func rewriteValueMIPS64_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVVconst [val])
for {
@@ -1198,7 +1198,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstBool_0(v *Value) bool {
+func rewriteValueMIPS64_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVVconst [b])
for {
@@ -1208,7 +1208,7 @@
return true
}
}
-func rewriteValueMIPS64_OpConstNil_0(v *Value) bool {
+func rewriteValueMIPS64_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVVconst [0])
for {
@@ -1217,7 +1217,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (TRUNCFW x)
@@ -1228,7 +1228,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 x)
// result: (TRUNCFV x)
@@ -1239,7 +1239,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (MOVFD x)
@@ -1250,7 +1250,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (MOVWF x)
@@ -1261,7 +1261,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (MOVWD x)
@@ -1272,7 +1272,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (TRUNCDW x)
@@ -1283,7 +1283,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (MOVDF x)
@@ -1294,7 +1294,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 x)
// result: (TRUNCDV x)
@@ -1305,7 +1305,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F x)
// result: (MOVVF x)
@@ -1316,7 +1316,7 @@
return true
}
}
-func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F x)
// result: (MOVVD x)
@@ -1327,7 +1327,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1349,7 +1349,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1371,7 +1371,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1393,7 +1393,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1407,7 +1407,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1429,7 +1429,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1447,7 +1447,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1461,7 +1461,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1479,7 +1479,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1501,7 +1501,7 @@
return true
}
}
-func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1523,7 +1523,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq16_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1548,7 +1548,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1573,7 +1573,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1590,7 +1590,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1611,7 +1611,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1628,7 +1628,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEq8_0(v *Value) bool {
+func rewriteValueMIPS64_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1653,7 +1653,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqB_0(v *Value) bool {
+func rewriteValueMIPS64_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1674,7 +1674,7 @@
return true
}
}
-func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1695,7 +1695,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq16_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1720,7 +1720,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1745,7 +1745,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1770,7 +1770,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1787,7 +1787,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1812,7 +1812,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1833,7 +1833,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1850,7 +1850,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1871,7 +1871,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq8_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1896,7 +1896,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1921,7 +1921,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueMIPS64_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -1929,7 +1929,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueMIPS64_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -1937,7 +1937,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -1945,7 +1945,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater16_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1965,7 +1965,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1985,7 +1985,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2005,7 +2005,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2022,7 +2022,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2042,7 +2042,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64 x y)
@@ -2056,7 +2056,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2073,7 +2073,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64U x y)
@@ -2087,7 +2087,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater8_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2107,7 +2107,7 @@
return true
}
}
-func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2127,7 +2127,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32_0(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2152,7 +2152,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2177,7 +2177,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64_0(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2195,7 +2195,7 @@
return true
}
}
-func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2213,7 +2213,7 @@
return true
}
}
-func rewriteValueMIPS64_OpInterCall_0(v *Value) bool {
+func rewriteValueMIPS64_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -2229,7 +2229,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool {
+func rewriteValueMIPS64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -2243,7 +2243,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool {
+func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2259,7 +2259,7 @@
return true
}
}
-func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2280,7 +2280,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2305,7 +2305,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2330,7 +2330,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2355,7 +2355,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2372,7 +2372,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2397,7 +2397,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2418,7 +2418,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2435,7 +2435,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2456,7 +2456,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2481,7 +2481,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2506,7 +2506,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2526,7 +2526,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess16U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2546,7 +2546,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2566,7 +2566,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2583,7 +2583,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess32U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2603,7 +2603,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 x y)
@@ -2617,7 +2617,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2634,7 +2634,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess64U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U x y)
@@ -2648,7 +2648,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2668,7 +2668,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLess8U_0(v *Value) bool {
+func rewriteValueMIPS64_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2688,7 +2688,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLoad_0(v *Value) bool {
+func rewriteValueMIPS64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2843,7 +2843,7 @@
}
return false
}
-func rewriteValueMIPS64_OpLocalAddr_0(v *Value) bool {
+func rewriteValueMIPS64_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVVaddr {sym} base)
@@ -2856,7 +2856,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2887,7 +2887,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2918,7 +2918,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2945,7 +2945,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2976,7 +2976,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3007,7 +3007,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3038,7 +3038,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3065,7 +3065,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3096,7 +3096,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3127,7 +3127,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3158,7 +3158,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3185,7 +3185,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3216,7 +3216,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3247,7 +3247,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3278,7 +3278,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3305,7 +3305,7 @@
return true
}
}
-func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3336,7 +3336,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDV x (MOVVconst [c]))
@@ -3377,7 +3377,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
// result: (MOVVaddr [off1+off2] {sym} ptr)
@@ -3457,7 +3457,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (MOVVconst [c]))
@@ -3494,7 +3494,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [0] _)
// result: (MOVVconst [0])
@@ -3546,7 +3546,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3571,7 +3571,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3596,7 +3596,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3615,7 +3615,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3634,7 +3634,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -3684,7 +3684,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -3722,7 +3722,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -3772,7 +3772,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVBreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -3810,7 +3810,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3996,7 +3996,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4046,7 +4046,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4096,7 +4096,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4151,7 +4151,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4201,7 +4201,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4256,7 +4256,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4306,7 +4306,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -4367,7 +4367,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4417,7 +4417,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVHreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -4501,7 +4501,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4649,7 +4649,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4699,7 +4699,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4749,7 +4749,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVVreg x)
// cond: x.Uses == 1
@@ -4776,7 +4776,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4848,7 +4848,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4898,7 +4898,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -4948,7 +4948,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWUreg x:(MOVBUload _ _))
// result: (MOVVreg x)
@@ -5032,7 +5032,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -5082,7 +5082,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool {
v_0 := v.Args[0]
// match: (MOVWreg x:(MOVBload _ _))
// result: (MOVVreg x)
@@ -5201,7 +5201,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5311,7 +5311,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
@@ -5361,7 +5361,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGV (MOVVconst [c]))
// result: (MOVVconst [-c])
@@ -5376,7 +5376,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NOR x (MOVVconst [c]))
@@ -5401,7 +5401,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (NORconst [c] (MOVVconst [d]))
// result: (MOVVconst [^(c|d)])
@@ -5417,7 +5417,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OR x (MOVVconst [c]))
@@ -5454,7 +5454,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -5510,7 +5510,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGT (MOVVconst [c]) x)
@@ -5532,7 +5532,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SGTU (MOVVconst [c]) x)
@@ -5554,7 +5554,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTUconst [c] (MOVVconst [d]))
// cond: uint64(c)>uint64(d)
@@ -5646,7 +5646,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SGTconst [c] (MOVVconst [d]))
// cond: c>d
@@ -5776,10 +5776,6 @@
v.AuxInt = 0
return true
}
- return false
-}
-func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (SGTconst [c] (MOVWUreg _))
// cond: c < 0
// result: (MOVVconst [0])
@@ -5826,7 +5822,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SLLV _ (MOVVconst [c]))
@@ -5859,7 +5855,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLVconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SLLVconst [c] (MOVVconst [d]))
// result: (MOVVconst [d<<uint64(c)])
@@ -5875,7 +5871,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRAV x (MOVVconst [c]))
@@ -5910,7 +5906,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRAVconst [c] (MOVVconst [d]))
// result: (MOVVconst [d>>uint64(c)])
@@ -5926,7 +5922,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SRLV _ (MOVVconst [c]))
@@ -5959,7 +5955,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRLVconst [c] (MOVVconst [d]))
// result: (MOVVconst [int64(uint64(d)>>uint64(c))])
@@ -5975,7 +5971,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUBV x (MOVVconst [c]))
@@ -6019,7 +6015,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBVconst [0] x)
// result: x
@@ -6083,7 +6079,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVVconst [c]))
@@ -6119,7 +6115,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -6177,7 +6173,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMod16_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6199,7 +6195,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod16u_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6221,7 +6217,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6243,7 +6239,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod32u_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6265,7 +6261,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6283,7 +6279,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod64u_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6301,7 +6297,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6323,7 +6319,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMod8u_0(v *Value) bool {
+func rewriteValueMIPS64_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6345,11 +6341,12 @@
return true
}
}
-func rewriteValueMIPS64_OpMove_0(v *Value) bool {
+func rewriteValueMIPS64_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Move [0] _ _ mem)
// result: mem
@@ -6636,15 +6633,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueMIPS64_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Move [3] dst src mem)
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
for {
@@ -6880,7 +6868,7 @@
}
return false
}
-func rewriteValueMIPS64_OpMul16_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6898,7 +6886,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul32_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6916,7 +6904,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -6930,7 +6918,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6948,7 +6936,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -6962,7 +6950,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul64uhilo_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul64uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64uhilo x y)
@@ -6976,7 +6964,7 @@
return true
}
}
-func rewriteValueMIPS64_OpMul8_0(v *Value) bool {
+func rewriteValueMIPS64_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6994,7 +6982,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg16_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEGV x)
@@ -7005,7 +6993,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg32_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEGV x)
@@ -7016,7 +7004,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (NEGF x)
@@ -7027,7 +7015,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg64_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64 x)
// result: (NEGV x)
@@ -7038,7 +7026,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (NEGD x)
@@ -7049,7 +7037,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeg8_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEGV x)
@@ -7060,7 +7048,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq16_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7085,7 +7073,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7110,7 +7098,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7127,7 +7115,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7148,7 +7136,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7165,7 +7153,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeq8_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7190,7 +7178,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeqB_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -7204,7 +7192,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7225,7 +7213,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool {
+func rewriteValueMIPS64_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -7239,7 +7227,7 @@
return true
}
}
-func rewriteValueMIPS64_OpNot_0(v *Value) bool {
+func rewriteValueMIPS64_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -7251,7 +7239,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr:(SP))
// result: (MOVVaddr [off] ptr)
@@ -7277,7 +7265,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr16_0(v *Value) bool {
+func rewriteValueMIPS64_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -7291,7 +7279,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr32_0(v *Value) bool {
+func rewriteValueMIPS64_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -7305,7 +7293,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr64_0(v *Value) bool {
+func rewriteValueMIPS64_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -7319,7 +7307,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOr8_0(v *Value) bool {
+func rewriteValueMIPS64_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -7333,7 +7321,7 @@
return true
}
}
-func rewriteValueMIPS64_OpOrB_0(v *Value) bool {
+func rewriteValueMIPS64_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -7347,7 +7335,7 @@
return true
}
}
-func rewriteValueMIPS64_OpPanicBounds_0(v *Value) bool {
+func rewriteValueMIPS64_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7407,7 +7395,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7438,7 +7426,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7469,7 +7457,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7500,7 +7488,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7531,7 +7519,7 @@
}
return false
}
-func rewriteValueMIPS64_OpRound32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -7543,7 +7531,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRound64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -7555,7 +7543,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7588,7 +7576,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7621,7 +7609,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7650,7 +7638,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7683,7 +7671,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7716,7 +7704,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7749,7 +7737,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7778,7 +7766,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7811,7 +7799,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7844,7 +7832,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7877,7 +7865,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7906,7 +7894,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7939,7 +7927,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7972,7 +7960,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8005,7 +7993,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8034,7 +8022,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8067,7 +8055,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8098,7 +8086,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8129,7 +8117,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8156,7 +8144,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8187,7 +8175,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8218,7 +8206,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8249,7 +8237,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8276,7 +8264,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8307,7 +8295,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8340,7 +8328,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8373,7 +8361,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8402,7 +8390,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8435,7 +8423,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8468,7 +8456,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8501,7 +8489,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8530,7 +8518,7 @@
return true
}
}
-func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8563,7 +8551,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSelect0_0(v *Value) bool {
+func rewriteValueMIPS64_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
// match: (Select0 (DIVVU _ (MOVVconst [1])))
// result: (MOVVconst [0])
@@ -8646,7 +8634,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSelect1_0(v *Value) bool {
+func rewriteValueMIPS64_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
// match: (Select1 (MULVU x (MOVVconst [-1])))
// result: (NEGV x)
@@ -8841,7 +8829,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -8852,7 +8840,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 x)
// result: (MOVHreg x)
@@ -8863,7 +8851,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 x)
// result: (MOVWreg x)
@@ -8874,7 +8862,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -8885,7 +8873,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -8896,7 +8884,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 x)
// result: (MOVBreg x)
@@ -8907,7 +8895,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool {
+func rewriteValueMIPS64_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -8923,7 +8911,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSqrt_0(v *Value) bool {
+func rewriteValueMIPS64_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (SQRTD x)
@@ -8934,7 +8922,7 @@
return true
}
}
-func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool {
+func rewriteValueMIPS64_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -8949,7 +8937,7 @@
return true
}
}
-func rewriteValueMIPS64_OpStore_0(v *Value) bool {
+func rewriteValueMIPS64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9057,7 +9045,7 @@
}
return false
}
-func rewriteValueMIPS64_OpSub16_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -9071,7 +9059,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub32_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -9085,7 +9073,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub32F_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -9099,7 +9087,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub64_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -9113,7 +9101,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub64F_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -9127,7 +9115,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSub8_0(v *Value) bool {
+func rewriteValueMIPS64_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -9141,7 +9129,7 @@
return true
}
}
-func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool {
+func rewriteValueMIPS64_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -9155,7 +9143,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -9167,7 +9155,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -9179,7 +9167,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -9191,7 +9179,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 x)
// result: x
@@ -9203,7 +9191,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 x)
// result: x
@@ -9215,7 +9203,7 @@
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 x)
// result: x
@@ -9227,7 +9215,7 @@
return true
}
}
-func rewriteValueMIPS64_OpWB_0(v *Value) bool {
+func rewriteValueMIPS64_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9246,7 +9234,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor16_0(v *Value) bool {
+func rewriteValueMIPS64_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -9260,7 +9248,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor32_0(v *Value) bool {
+func rewriteValueMIPS64_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -9274,7 +9262,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor64_0(v *Value) bool {
+func rewriteValueMIPS64_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -9288,7 +9276,7 @@
return true
}
}
-func rewriteValueMIPS64_OpXor8_0(v *Value) bool {
+func rewriteValueMIPS64_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -9302,10 +9290,11 @@
return true
}
}
-func rewriteValueMIPS64_OpZero_0(v *Value) bool {
+func rewriteValueMIPS64_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
typ := &b.Func.Config.Types
// match: (Zero [0] _ mem)
// result: mem
@@ -9561,14 +9550,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueMIPS64_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (Zero [3] ptr mem)
// result: (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem)))
for {
@@ -9777,7 +9758,7 @@
}
return false
}
-func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHUreg x)
@@ -9788,7 +9769,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 x)
// result: (MOVHUreg x)
@@ -9799,7 +9780,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 x)
// result: (MOVWUreg x)
@@ -9810,7 +9791,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBUreg x)
@@ -9821,7 +9802,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBUreg x)
@@ -9832,7 +9813,7 @@
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 x)
// result: (MOVBUreg x)
diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go
index 9ac9cf3..12fdcae 100644
--- a/src/cmd/compile/internal/ssa/rewritePPC64.go
+++ b/src/cmd/compile/internal/ssa/rewritePPC64.go
@@ -10,721 +10,721 @@
func rewriteValuePPC64(v *Value) bool {
switch v.Op {
case OpAbs:
- return rewriteValuePPC64_OpAbs_0(v)
+ return rewriteValuePPC64_OpAbs(v)
case OpAdd16:
- return rewriteValuePPC64_OpAdd16_0(v)
+ return rewriteValuePPC64_OpAdd16(v)
case OpAdd32:
- return rewriteValuePPC64_OpAdd32_0(v)
+ return rewriteValuePPC64_OpAdd32(v)
case OpAdd32F:
- return rewriteValuePPC64_OpAdd32F_0(v)
+ return rewriteValuePPC64_OpAdd32F(v)
case OpAdd64:
- return rewriteValuePPC64_OpAdd64_0(v)
+ return rewriteValuePPC64_OpAdd64(v)
case OpAdd64F:
- return rewriteValuePPC64_OpAdd64F_0(v)
+ return rewriteValuePPC64_OpAdd64F(v)
case OpAdd64carry:
- return rewriteValuePPC64_OpAdd64carry_0(v)
+ return rewriteValuePPC64_OpAdd64carry(v)
case OpAdd8:
- return rewriteValuePPC64_OpAdd8_0(v)
+ return rewriteValuePPC64_OpAdd8(v)
case OpAddPtr:
- return rewriteValuePPC64_OpAddPtr_0(v)
+ return rewriteValuePPC64_OpAddPtr(v)
case OpAddr:
- return rewriteValuePPC64_OpAddr_0(v)
+ return rewriteValuePPC64_OpAddr(v)
case OpAnd16:
- return rewriteValuePPC64_OpAnd16_0(v)
+ return rewriteValuePPC64_OpAnd16(v)
case OpAnd32:
- return rewriteValuePPC64_OpAnd32_0(v)
+ return rewriteValuePPC64_OpAnd32(v)
case OpAnd64:
- return rewriteValuePPC64_OpAnd64_0(v)
+ return rewriteValuePPC64_OpAnd64(v)
case OpAnd8:
- return rewriteValuePPC64_OpAnd8_0(v)
+ return rewriteValuePPC64_OpAnd8(v)
case OpAndB:
- return rewriteValuePPC64_OpAndB_0(v)
+ return rewriteValuePPC64_OpAndB(v)
case OpAtomicAdd32:
- return rewriteValuePPC64_OpAtomicAdd32_0(v)
+ return rewriteValuePPC64_OpAtomicAdd32(v)
case OpAtomicAdd64:
- return rewriteValuePPC64_OpAtomicAdd64_0(v)
+ return rewriteValuePPC64_OpAtomicAdd64(v)
case OpAtomicAnd8:
- return rewriteValuePPC64_OpAtomicAnd8_0(v)
+ return rewriteValuePPC64_OpAtomicAnd8(v)
case OpAtomicCompareAndSwap32:
- return rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap32(v)
case OpAtomicCompareAndSwap64:
- return rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap64(v)
case OpAtomicCompareAndSwapRel32:
- return rewriteValuePPC64_OpAtomicCompareAndSwapRel32_0(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwapRel32(v)
case OpAtomicExchange32:
- return rewriteValuePPC64_OpAtomicExchange32_0(v)
+ return rewriteValuePPC64_OpAtomicExchange32(v)
case OpAtomicExchange64:
- return rewriteValuePPC64_OpAtomicExchange64_0(v)
+ return rewriteValuePPC64_OpAtomicExchange64(v)
case OpAtomicLoad32:
- return rewriteValuePPC64_OpAtomicLoad32_0(v)
+ return rewriteValuePPC64_OpAtomicLoad32(v)
case OpAtomicLoad64:
- return rewriteValuePPC64_OpAtomicLoad64_0(v)
+ return rewriteValuePPC64_OpAtomicLoad64(v)
case OpAtomicLoad8:
- return rewriteValuePPC64_OpAtomicLoad8_0(v)
+ return rewriteValuePPC64_OpAtomicLoad8(v)
case OpAtomicLoadAcq32:
- return rewriteValuePPC64_OpAtomicLoadAcq32_0(v)
+ return rewriteValuePPC64_OpAtomicLoadAcq32(v)
case OpAtomicLoadPtr:
- return rewriteValuePPC64_OpAtomicLoadPtr_0(v)
+ return rewriteValuePPC64_OpAtomicLoadPtr(v)
case OpAtomicOr8:
- return rewriteValuePPC64_OpAtomicOr8_0(v)
+ return rewriteValuePPC64_OpAtomicOr8(v)
case OpAtomicStore32:
- return rewriteValuePPC64_OpAtomicStore32_0(v)
+ return rewriteValuePPC64_OpAtomicStore32(v)
case OpAtomicStore64:
- return rewriteValuePPC64_OpAtomicStore64_0(v)
+ return rewriteValuePPC64_OpAtomicStore64(v)
case OpAtomicStore8:
- return rewriteValuePPC64_OpAtomicStore8_0(v)
+ return rewriteValuePPC64_OpAtomicStore8(v)
case OpAtomicStoreRel32:
- return rewriteValuePPC64_OpAtomicStoreRel32_0(v)
+ return rewriteValuePPC64_OpAtomicStoreRel32(v)
case OpAvg64u:
- return rewriteValuePPC64_OpAvg64u_0(v)
+ return rewriteValuePPC64_OpAvg64u(v)
case OpBitLen32:
- return rewriteValuePPC64_OpBitLen32_0(v)
+ return rewriteValuePPC64_OpBitLen32(v)
case OpBitLen64:
- return rewriteValuePPC64_OpBitLen64_0(v)
+ return rewriteValuePPC64_OpBitLen64(v)
case OpCeil:
- return rewriteValuePPC64_OpCeil_0(v)
+ return rewriteValuePPC64_OpCeil(v)
case OpClosureCall:
- return rewriteValuePPC64_OpClosureCall_0(v)
+ return rewriteValuePPC64_OpClosureCall(v)
case OpCom16:
- return rewriteValuePPC64_OpCom16_0(v)
+ return rewriteValuePPC64_OpCom16(v)
case OpCom32:
- return rewriteValuePPC64_OpCom32_0(v)
+ return rewriteValuePPC64_OpCom32(v)
case OpCom64:
- return rewriteValuePPC64_OpCom64_0(v)
+ return rewriteValuePPC64_OpCom64(v)
case OpCom8:
- return rewriteValuePPC64_OpCom8_0(v)
+ return rewriteValuePPC64_OpCom8(v)
case OpCondSelect:
- return rewriteValuePPC64_OpCondSelect_0(v)
+ return rewriteValuePPC64_OpCondSelect(v)
case OpConst16:
- return rewriteValuePPC64_OpConst16_0(v)
+ return rewriteValuePPC64_OpConst16(v)
case OpConst32:
- return rewriteValuePPC64_OpConst32_0(v)
+ return rewriteValuePPC64_OpConst32(v)
case OpConst32F:
- return rewriteValuePPC64_OpConst32F_0(v)
+ return rewriteValuePPC64_OpConst32F(v)
case OpConst64:
- return rewriteValuePPC64_OpConst64_0(v)
+ return rewriteValuePPC64_OpConst64(v)
case OpConst64F:
- return rewriteValuePPC64_OpConst64F_0(v)
+ return rewriteValuePPC64_OpConst64F(v)
case OpConst8:
- return rewriteValuePPC64_OpConst8_0(v)
+ return rewriteValuePPC64_OpConst8(v)
case OpConstBool:
- return rewriteValuePPC64_OpConstBool_0(v)
+ return rewriteValuePPC64_OpConstBool(v)
case OpConstNil:
- return rewriteValuePPC64_OpConstNil_0(v)
+ return rewriteValuePPC64_OpConstNil(v)
case OpCopysign:
- return rewriteValuePPC64_OpCopysign_0(v)
+ return rewriteValuePPC64_OpCopysign(v)
case OpCtz16:
- return rewriteValuePPC64_OpCtz16_0(v)
+ return rewriteValuePPC64_OpCtz16(v)
case OpCtz32:
- return rewriteValuePPC64_OpCtz32_0(v)
+ return rewriteValuePPC64_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValuePPC64_OpCtz32NonZero_0(v)
+ return rewriteValuePPC64_OpCtz32NonZero(v)
case OpCtz64:
- return rewriteValuePPC64_OpCtz64_0(v)
+ return rewriteValuePPC64_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValuePPC64_OpCtz64NonZero_0(v)
+ return rewriteValuePPC64_OpCtz64NonZero(v)
case OpCtz8:
- return rewriteValuePPC64_OpCtz8_0(v)
+ return rewriteValuePPC64_OpCtz8(v)
case OpCvt32Fto32:
- return rewriteValuePPC64_OpCvt32Fto32_0(v)
+ return rewriteValuePPC64_OpCvt32Fto32(v)
case OpCvt32Fto64:
- return rewriteValuePPC64_OpCvt32Fto64_0(v)
+ return rewriteValuePPC64_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValuePPC64_OpCvt32Fto64F_0(v)
+ return rewriteValuePPC64_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValuePPC64_OpCvt32to32F_0(v)
+ return rewriteValuePPC64_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValuePPC64_OpCvt32to64F_0(v)
+ return rewriteValuePPC64_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValuePPC64_OpCvt64Fto32_0(v)
+ return rewriteValuePPC64_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValuePPC64_OpCvt64Fto32F_0(v)
+ return rewriteValuePPC64_OpCvt64Fto32F(v)
case OpCvt64Fto64:
- return rewriteValuePPC64_OpCvt64Fto64_0(v)
+ return rewriteValuePPC64_OpCvt64Fto64(v)
case OpCvt64to32F:
- return rewriteValuePPC64_OpCvt64to32F_0(v)
+ return rewriteValuePPC64_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValuePPC64_OpCvt64to64F_0(v)
+ return rewriteValuePPC64_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValuePPC64_OpDiv16_0(v)
+ return rewriteValuePPC64_OpDiv16(v)
case OpDiv16u:
- return rewriteValuePPC64_OpDiv16u_0(v)
+ return rewriteValuePPC64_OpDiv16u(v)
case OpDiv32:
- return rewriteValuePPC64_OpDiv32_0(v)
+ return rewriteValuePPC64_OpDiv32(v)
case OpDiv32F:
- return rewriteValuePPC64_OpDiv32F_0(v)
+ return rewriteValuePPC64_OpDiv32F(v)
case OpDiv32u:
- return rewriteValuePPC64_OpDiv32u_0(v)
+ return rewriteValuePPC64_OpDiv32u(v)
case OpDiv64:
- return rewriteValuePPC64_OpDiv64_0(v)
+ return rewriteValuePPC64_OpDiv64(v)
case OpDiv64F:
- return rewriteValuePPC64_OpDiv64F_0(v)
+ return rewriteValuePPC64_OpDiv64F(v)
case OpDiv64u:
- return rewriteValuePPC64_OpDiv64u_0(v)
+ return rewriteValuePPC64_OpDiv64u(v)
case OpDiv8:
- return rewriteValuePPC64_OpDiv8_0(v)
+ return rewriteValuePPC64_OpDiv8(v)
case OpDiv8u:
- return rewriteValuePPC64_OpDiv8u_0(v)
+ return rewriteValuePPC64_OpDiv8u(v)
case OpEq16:
- return rewriteValuePPC64_OpEq16_0(v)
+ return rewriteValuePPC64_OpEq16(v)
case OpEq32:
- return rewriteValuePPC64_OpEq32_0(v)
+ return rewriteValuePPC64_OpEq32(v)
case OpEq32F:
- return rewriteValuePPC64_OpEq32F_0(v)
+ return rewriteValuePPC64_OpEq32F(v)
case OpEq64:
- return rewriteValuePPC64_OpEq64_0(v)
+ return rewriteValuePPC64_OpEq64(v)
case OpEq64F:
- return rewriteValuePPC64_OpEq64F_0(v)
+ return rewriteValuePPC64_OpEq64F(v)
case OpEq8:
- return rewriteValuePPC64_OpEq8_0(v)
+ return rewriteValuePPC64_OpEq8(v)
case OpEqB:
- return rewriteValuePPC64_OpEqB_0(v)
+ return rewriteValuePPC64_OpEqB(v)
case OpEqPtr:
- return rewriteValuePPC64_OpEqPtr_0(v)
+ return rewriteValuePPC64_OpEqPtr(v)
case OpFMA:
- return rewriteValuePPC64_OpFMA_0(v)
+ return rewriteValuePPC64_OpFMA(v)
case OpFloor:
- return rewriteValuePPC64_OpFloor_0(v)
+ return rewriteValuePPC64_OpFloor(v)
case OpGeq16:
- return rewriteValuePPC64_OpGeq16_0(v)
+ return rewriteValuePPC64_OpGeq16(v)
case OpGeq16U:
- return rewriteValuePPC64_OpGeq16U_0(v)
+ return rewriteValuePPC64_OpGeq16U(v)
case OpGeq32:
- return rewriteValuePPC64_OpGeq32_0(v)
+ return rewriteValuePPC64_OpGeq32(v)
case OpGeq32F:
- return rewriteValuePPC64_OpGeq32F_0(v)
+ return rewriteValuePPC64_OpGeq32F(v)
case OpGeq32U:
- return rewriteValuePPC64_OpGeq32U_0(v)
+ return rewriteValuePPC64_OpGeq32U(v)
case OpGeq64:
- return rewriteValuePPC64_OpGeq64_0(v)
+ return rewriteValuePPC64_OpGeq64(v)
case OpGeq64F:
- return rewriteValuePPC64_OpGeq64F_0(v)
+ return rewriteValuePPC64_OpGeq64F(v)
case OpGeq64U:
- return rewriteValuePPC64_OpGeq64U_0(v)
+ return rewriteValuePPC64_OpGeq64U(v)
case OpGeq8:
- return rewriteValuePPC64_OpGeq8_0(v)
+ return rewriteValuePPC64_OpGeq8(v)
case OpGeq8U:
- return rewriteValuePPC64_OpGeq8U_0(v)
+ return rewriteValuePPC64_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValuePPC64_OpGetCallerPC_0(v)
+ return rewriteValuePPC64_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValuePPC64_OpGetCallerSP_0(v)
+ return rewriteValuePPC64_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValuePPC64_OpGetClosurePtr_0(v)
+ return rewriteValuePPC64_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValuePPC64_OpGreater16_0(v)
+ return rewriteValuePPC64_OpGreater16(v)
case OpGreater16U:
- return rewriteValuePPC64_OpGreater16U_0(v)
+ return rewriteValuePPC64_OpGreater16U(v)
case OpGreater32:
- return rewriteValuePPC64_OpGreater32_0(v)
+ return rewriteValuePPC64_OpGreater32(v)
case OpGreater32F:
- return rewriteValuePPC64_OpGreater32F_0(v)
+ return rewriteValuePPC64_OpGreater32F(v)
case OpGreater32U:
- return rewriteValuePPC64_OpGreater32U_0(v)
+ return rewriteValuePPC64_OpGreater32U(v)
case OpGreater64:
- return rewriteValuePPC64_OpGreater64_0(v)
+ return rewriteValuePPC64_OpGreater64(v)
case OpGreater64F:
- return rewriteValuePPC64_OpGreater64F_0(v)
+ return rewriteValuePPC64_OpGreater64F(v)
case OpGreater64U:
- return rewriteValuePPC64_OpGreater64U_0(v)
+ return rewriteValuePPC64_OpGreater64U(v)
case OpGreater8:
- return rewriteValuePPC64_OpGreater8_0(v)
+ return rewriteValuePPC64_OpGreater8(v)
case OpGreater8U:
- return rewriteValuePPC64_OpGreater8U_0(v)
+ return rewriteValuePPC64_OpGreater8U(v)
case OpHmul32:
- return rewriteValuePPC64_OpHmul32_0(v)
+ return rewriteValuePPC64_OpHmul32(v)
case OpHmul32u:
- return rewriteValuePPC64_OpHmul32u_0(v)
+ return rewriteValuePPC64_OpHmul32u(v)
case OpHmul64:
- return rewriteValuePPC64_OpHmul64_0(v)
+ return rewriteValuePPC64_OpHmul64(v)
case OpHmul64u:
- return rewriteValuePPC64_OpHmul64u_0(v)
+ return rewriteValuePPC64_OpHmul64u(v)
case OpInterCall:
- return rewriteValuePPC64_OpInterCall_0(v)
+ return rewriteValuePPC64_OpInterCall(v)
case OpIsInBounds:
- return rewriteValuePPC64_OpIsInBounds_0(v)
+ return rewriteValuePPC64_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValuePPC64_OpIsNonNil_0(v)
+ return rewriteValuePPC64_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValuePPC64_OpIsSliceInBounds_0(v)
+ return rewriteValuePPC64_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValuePPC64_OpLeq16_0(v)
+ return rewriteValuePPC64_OpLeq16(v)
case OpLeq16U:
- return rewriteValuePPC64_OpLeq16U_0(v)
+ return rewriteValuePPC64_OpLeq16U(v)
case OpLeq32:
- return rewriteValuePPC64_OpLeq32_0(v)
+ return rewriteValuePPC64_OpLeq32(v)
case OpLeq32F:
- return rewriteValuePPC64_OpLeq32F_0(v)
+ return rewriteValuePPC64_OpLeq32F(v)
case OpLeq32U:
- return rewriteValuePPC64_OpLeq32U_0(v)
+ return rewriteValuePPC64_OpLeq32U(v)
case OpLeq64:
- return rewriteValuePPC64_OpLeq64_0(v)
+ return rewriteValuePPC64_OpLeq64(v)
case OpLeq64F:
- return rewriteValuePPC64_OpLeq64F_0(v)
+ return rewriteValuePPC64_OpLeq64F(v)
case OpLeq64U:
- return rewriteValuePPC64_OpLeq64U_0(v)
+ return rewriteValuePPC64_OpLeq64U(v)
case OpLeq8:
- return rewriteValuePPC64_OpLeq8_0(v)
+ return rewriteValuePPC64_OpLeq8(v)
case OpLeq8U:
- return rewriteValuePPC64_OpLeq8U_0(v)
+ return rewriteValuePPC64_OpLeq8U(v)
case OpLess16:
- return rewriteValuePPC64_OpLess16_0(v)
+ return rewriteValuePPC64_OpLess16(v)
case OpLess16U:
- return rewriteValuePPC64_OpLess16U_0(v)
+ return rewriteValuePPC64_OpLess16U(v)
case OpLess32:
- return rewriteValuePPC64_OpLess32_0(v)
+ return rewriteValuePPC64_OpLess32(v)
case OpLess32F:
- return rewriteValuePPC64_OpLess32F_0(v)
+ return rewriteValuePPC64_OpLess32F(v)
case OpLess32U:
- return rewriteValuePPC64_OpLess32U_0(v)
+ return rewriteValuePPC64_OpLess32U(v)
case OpLess64:
- return rewriteValuePPC64_OpLess64_0(v)
+ return rewriteValuePPC64_OpLess64(v)
case OpLess64F:
- return rewriteValuePPC64_OpLess64F_0(v)
+ return rewriteValuePPC64_OpLess64F(v)
case OpLess64U:
- return rewriteValuePPC64_OpLess64U_0(v)
+ return rewriteValuePPC64_OpLess64U(v)
case OpLess8:
- return rewriteValuePPC64_OpLess8_0(v)
+ return rewriteValuePPC64_OpLess8(v)
case OpLess8U:
- return rewriteValuePPC64_OpLess8U_0(v)
+ return rewriteValuePPC64_OpLess8U(v)
case OpLoad:
- return rewriteValuePPC64_OpLoad_0(v)
+ return rewriteValuePPC64_OpLoad(v)
case OpLocalAddr:
- return rewriteValuePPC64_OpLocalAddr_0(v)
+ return rewriteValuePPC64_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValuePPC64_OpLsh16x16_0(v)
+ return rewriteValuePPC64_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValuePPC64_OpLsh16x32_0(v)
+ return rewriteValuePPC64_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValuePPC64_OpLsh16x64_0(v)
+ return rewriteValuePPC64_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValuePPC64_OpLsh16x8_0(v)
+ return rewriteValuePPC64_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValuePPC64_OpLsh32x16_0(v)
+ return rewriteValuePPC64_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValuePPC64_OpLsh32x32_0(v)
+ return rewriteValuePPC64_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValuePPC64_OpLsh32x64_0(v)
+ return rewriteValuePPC64_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValuePPC64_OpLsh32x8_0(v)
+ return rewriteValuePPC64_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValuePPC64_OpLsh64x16_0(v)
+ return rewriteValuePPC64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValuePPC64_OpLsh64x32_0(v)
+ return rewriteValuePPC64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValuePPC64_OpLsh64x64_0(v)
+ return rewriteValuePPC64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValuePPC64_OpLsh64x8_0(v)
+ return rewriteValuePPC64_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValuePPC64_OpLsh8x16_0(v)
+ return rewriteValuePPC64_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValuePPC64_OpLsh8x32_0(v)
+ return rewriteValuePPC64_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValuePPC64_OpLsh8x64_0(v)
+ return rewriteValuePPC64_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValuePPC64_OpLsh8x8_0(v)
+ return rewriteValuePPC64_OpLsh8x8(v)
case OpMod16:
- return rewriteValuePPC64_OpMod16_0(v)
+ return rewriteValuePPC64_OpMod16(v)
case OpMod16u:
- return rewriteValuePPC64_OpMod16u_0(v)
+ return rewriteValuePPC64_OpMod16u(v)
case OpMod32:
- return rewriteValuePPC64_OpMod32_0(v)
+ return rewriteValuePPC64_OpMod32(v)
case OpMod32u:
- return rewriteValuePPC64_OpMod32u_0(v)
+ return rewriteValuePPC64_OpMod32u(v)
case OpMod64:
- return rewriteValuePPC64_OpMod64_0(v)
+ return rewriteValuePPC64_OpMod64(v)
case OpMod64u:
- return rewriteValuePPC64_OpMod64u_0(v)
+ return rewriteValuePPC64_OpMod64u(v)
case OpMod8:
- return rewriteValuePPC64_OpMod8_0(v)
+ return rewriteValuePPC64_OpMod8(v)
case OpMod8u:
- return rewriteValuePPC64_OpMod8u_0(v)
+ return rewriteValuePPC64_OpMod8u(v)
case OpMove:
- return rewriteValuePPC64_OpMove_0(v) || rewriteValuePPC64_OpMove_10(v)
+ return rewriteValuePPC64_OpMove(v)
case OpMul16:
- return rewriteValuePPC64_OpMul16_0(v)
+ return rewriteValuePPC64_OpMul16(v)
case OpMul32:
- return rewriteValuePPC64_OpMul32_0(v)
+ return rewriteValuePPC64_OpMul32(v)
case OpMul32F:
- return rewriteValuePPC64_OpMul32F_0(v)
+ return rewriteValuePPC64_OpMul32F(v)
case OpMul64:
- return rewriteValuePPC64_OpMul64_0(v)
+ return rewriteValuePPC64_OpMul64(v)
case OpMul64F:
- return rewriteValuePPC64_OpMul64F_0(v)
+ return rewriteValuePPC64_OpMul64F(v)
case OpMul64uhilo:
- return rewriteValuePPC64_OpMul64uhilo_0(v)
+ return rewriteValuePPC64_OpMul64uhilo(v)
case OpMul8:
- return rewriteValuePPC64_OpMul8_0(v)
+ return rewriteValuePPC64_OpMul8(v)
case OpNeg16:
- return rewriteValuePPC64_OpNeg16_0(v)
+ return rewriteValuePPC64_OpNeg16(v)
case OpNeg32:
- return rewriteValuePPC64_OpNeg32_0(v)
+ return rewriteValuePPC64_OpNeg32(v)
case OpNeg32F:
- return rewriteValuePPC64_OpNeg32F_0(v)
+ return rewriteValuePPC64_OpNeg32F(v)
case OpNeg64:
- return rewriteValuePPC64_OpNeg64_0(v)
+ return rewriteValuePPC64_OpNeg64(v)
case OpNeg64F:
- return rewriteValuePPC64_OpNeg64F_0(v)
+ return rewriteValuePPC64_OpNeg64F(v)
case OpNeg8:
- return rewriteValuePPC64_OpNeg8_0(v)
+ return rewriteValuePPC64_OpNeg8(v)
case OpNeq16:
- return rewriteValuePPC64_OpNeq16_0(v)
+ return rewriteValuePPC64_OpNeq16(v)
case OpNeq32:
- return rewriteValuePPC64_OpNeq32_0(v)
+ return rewriteValuePPC64_OpNeq32(v)
case OpNeq32F:
- return rewriteValuePPC64_OpNeq32F_0(v)
+ return rewriteValuePPC64_OpNeq32F(v)
case OpNeq64:
- return rewriteValuePPC64_OpNeq64_0(v)
+ return rewriteValuePPC64_OpNeq64(v)
case OpNeq64F:
- return rewriteValuePPC64_OpNeq64F_0(v)
+ return rewriteValuePPC64_OpNeq64F(v)
case OpNeq8:
- return rewriteValuePPC64_OpNeq8_0(v)
+ return rewriteValuePPC64_OpNeq8(v)
case OpNeqB:
- return rewriteValuePPC64_OpNeqB_0(v)
+ return rewriteValuePPC64_OpNeqB(v)
case OpNeqPtr:
- return rewriteValuePPC64_OpNeqPtr_0(v)
+ return rewriteValuePPC64_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValuePPC64_OpNilCheck_0(v)
+ return rewriteValuePPC64_OpNilCheck(v)
case OpNot:
- return rewriteValuePPC64_OpNot_0(v)
+ return rewriteValuePPC64_OpNot(v)
case OpOffPtr:
- return rewriteValuePPC64_OpOffPtr_0(v)
+ return rewriteValuePPC64_OpOffPtr(v)
case OpOr16:
- return rewriteValuePPC64_OpOr16_0(v)
+ return rewriteValuePPC64_OpOr16(v)
case OpOr32:
- return rewriteValuePPC64_OpOr32_0(v)
+ return rewriteValuePPC64_OpOr32(v)
case OpOr64:
- return rewriteValuePPC64_OpOr64_0(v)
+ return rewriteValuePPC64_OpOr64(v)
case OpOr8:
- return rewriteValuePPC64_OpOr8_0(v)
+ return rewriteValuePPC64_OpOr8(v)
case OpOrB:
- return rewriteValuePPC64_OpOrB_0(v)
+ return rewriteValuePPC64_OpOrB(v)
case OpPPC64ADD:
- return rewriteValuePPC64_OpPPC64ADD_0(v)
+ return rewriteValuePPC64_OpPPC64ADD(v)
case OpPPC64ADDconst:
- return rewriteValuePPC64_OpPPC64ADDconst_0(v)
+ return rewriteValuePPC64_OpPPC64ADDconst(v)
case OpPPC64AND:
- return rewriteValuePPC64_OpPPC64AND_0(v)
+ return rewriteValuePPC64_OpPPC64AND(v)
case OpPPC64ANDconst:
- return rewriteValuePPC64_OpPPC64ANDconst_0(v) || rewriteValuePPC64_OpPPC64ANDconst_10(v)
+ return rewriteValuePPC64_OpPPC64ANDconst(v)
case OpPPC64CMP:
- return rewriteValuePPC64_OpPPC64CMP_0(v)
+ return rewriteValuePPC64_OpPPC64CMP(v)
case OpPPC64CMPU:
- return rewriteValuePPC64_OpPPC64CMPU_0(v)
+ return rewriteValuePPC64_OpPPC64CMPU(v)
case OpPPC64CMPUconst:
- return rewriteValuePPC64_OpPPC64CMPUconst_0(v)
+ return rewriteValuePPC64_OpPPC64CMPUconst(v)
case OpPPC64CMPW:
- return rewriteValuePPC64_OpPPC64CMPW_0(v)
+ return rewriteValuePPC64_OpPPC64CMPW(v)
case OpPPC64CMPWU:
- return rewriteValuePPC64_OpPPC64CMPWU_0(v)
+ return rewriteValuePPC64_OpPPC64CMPWU(v)
case OpPPC64CMPWUconst:
- return rewriteValuePPC64_OpPPC64CMPWUconst_0(v)
+ return rewriteValuePPC64_OpPPC64CMPWUconst(v)
case OpPPC64CMPWconst:
- return rewriteValuePPC64_OpPPC64CMPWconst_0(v)
+ return rewriteValuePPC64_OpPPC64CMPWconst(v)
case OpPPC64CMPconst:
- return rewriteValuePPC64_OpPPC64CMPconst_0(v)
+ return rewriteValuePPC64_OpPPC64CMPconst(v)
case OpPPC64Equal:
- return rewriteValuePPC64_OpPPC64Equal_0(v)
+ return rewriteValuePPC64_OpPPC64Equal(v)
case OpPPC64FABS:
- return rewriteValuePPC64_OpPPC64FABS_0(v)
+ return rewriteValuePPC64_OpPPC64FABS(v)
case OpPPC64FADD:
- return rewriteValuePPC64_OpPPC64FADD_0(v)
+ return rewriteValuePPC64_OpPPC64FADD(v)
case OpPPC64FADDS:
- return rewriteValuePPC64_OpPPC64FADDS_0(v)
+ return rewriteValuePPC64_OpPPC64FADDS(v)
case OpPPC64FCEIL:
- return rewriteValuePPC64_OpPPC64FCEIL_0(v)
+ return rewriteValuePPC64_OpPPC64FCEIL(v)
case OpPPC64FFLOOR:
- return rewriteValuePPC64_OpPPC64FFLOOR_0(v)
+ return rewriteValuePPC64_OpPPC64FFLOOR(v)
case OpPPC64FGreaterEqual:
- return rewriteValuePPC64_OpPPC64FGreaterEqual_0(v)
+ return rewriteValuePPC64_OpPPC64FGreaterEqual(v)
case OpPPC64FGreaterThan:
- return rewriteValuePPC64_OpPPC64FGreaterThan_0(v)
+ return rewriteValuePPC64_OpPPC64FGreaterThan(v)
case OpPPC64FLessEqual:
- return rewriteValuePPC64_OpPPC64FLessEqual_0(v)
+ return rewriteValuePPC64_OpPPC64FLessEqual(v)
case OpPPC64FLessThan:
- return rewriteValuePPC64_OpPPC64FLessThan_0(v)
+ return rewriteValuePPC64_OpPPC64FLessThan(v)
case OpPPC64FMOVDload:
- return rewriteValuePPC64_OpPPC64FMOVDload_0(v)
+ return rewriteValuePPC64_OpPPC64FMOVDload(v)
case OpPPC64FMOVDstore:
- return rewriteValuePPC64_OpPPC64FMOVDstore_0(v)
+ return rewriteValuePPC64_OpPPC64FMOVDstore(v)
case OpPPC64FMOVSload:
- return rewriteValuePPC64_OpPPC64FMOVSload_0(v)
+ return rewriteValuePPC64_OpPPC64FMOVSload(v)
case OpPPC64FMOVSstore:
- return rewriteValuePPC64_OpPPC64FMOVSstore_0(v)
+ return rewriteValuePPC64_OpPPC64FMOVSstore(v)
case OpPPC64FNEG:
- return rewriteValuePPC64_OpPPC64FNEG_0(v)
+ return rewriteValuePPC64_OpPPC64FNEG(v)
case OpPPC64FSQRT:
- return rewriteValuePPC64_OpPPC64FSQRT_0(v)
+ return rewriteValuePPC64_OpPPC64FSQRT(v)
case OpPPC64FSUB:
- return rewriteValuePPC64_OpPPC64FSUB_0(v)
+ return rewriteValuePPC64_OpPPC64FSUB(v)
case OpPPC64FSUBS:
- return rewriteValuePPC64_OpPPC64FSUBS_0(v)
+ return rewriteValuePPC64_OpPPC64FSUBS(v)
case OpPPC64FTRUNC:
- return rewriteValuePPC64_OpPPC64FTRUNC_0(v)
+ return rewriteValuePPC64_OpPPC64FTRUNC(v)
case OpPPC64GreaterEqual:
- return rewriteValuePPC64_OpPPC64GreaterEqual_0(v)
+ return rewriteValuePPC64_OpPPC64GreaterEqual(v)
case OpPPC64GreaterThan:
- return rewriteValuePPC64_OpPPC64GreaterThan_0(v)
+ return rewriteValuePPC64_OpPPC64GreaterThan(v)
case OpPPC64ISEL:
- return rewriteValuePPC64_OpPPC64ISEL_0(v) || rewriteValuePPC64_OpPPC64ISEL_10(v) || rewriteValuePPC64_OpPPC64ISEL_20(v)
+ return rewriteValuePPC64_OpPPC64ISEL(v)
case OpPPC64ISELB:
- return rewriteValuePPC64_OpPPC64ISELB_0(v) || rewriteValuePPC64_OpPPC64ISELB_10(v) || rewriteValuePPC64_OpPPC64ISELB_20(v)
+ return rewriteValuePPC64_OpPPC64ISELB(v)
case OpPPC64LessEqual:
- return rewriteValuePPC64_OpPPC64LessEqual_0(v)
+ return rewriteValuePPC64_OpPPC64LessEqual(v)
case OpPPC64LessThan:
- return rewriteValuePPC64_OpPPC64LessThan_0(v)
+ return rewriteValuePPC64_OpPPC64LessThan(v)
case OpPPC64MFVSRD:
- return rewriteValuePPC64_OpPPC64MFVSRD_0(v)
+ return rewriteValuePPC64_OpPPC64MFVSRD(v)
case OpPPC64MOVBZload:
- return rewriteValuePPC64_OpPPC64MOVBZload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVBZload(v)
case OpPPC64MOVBZloadidx:
- return rewriteValuePPC64_OpPPC64MOVBZloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVBZloadidx(v)
case OpPPC64MOVBZreg:
- return rewriteValuePPC64_OpPPC64MOVBZreg_0(v) || rewriteValuePPC64_OpPPC64MOVBZreg_10(v)
+ return rewriteValuePPC64_OpPPC64MOVBZreg(v)
case OpPPC64MOVBreg:
- return rewriteValuePPC64_OpPPC64MOVBreg_0(v) || rewriteValuePPC64_OpPPC64MOVBreg_10(v)
+ return rewriteValuePPC64_OpPPC64MOVBreg(v)
case OpPPC64MOVBstore:
- return rewriteValuePPC64_OpPPC64MOVBstore_0(v) || rewriteValuePPC64_OpPPC64MOVBstore_10(v) || rewriteValuePPC64_OpPPC64MOVBstore_20(v)
+ return rewriteValuePPC64_OpPPC64MOVBstore(v)
case OpPPC64MOVBstoreidx:
- return rewriteValuePPC64_OpPPC64MOVBstoreidx_0(v) || rewriteValuePPC64_OpPPC64MOVBstoreidx_10(v)
+ return rewriteValuePPC64_OpPPC64MOVBstoreidx(v)
case OpPPC64MOVBstorezero:
- return rewriteValuePPC64_OpPPC64MOVBstorezero_0(v)
+ return rewriteValuePPC64_OpPPC64MOVBstorezero(v)
case OpPPC64MOVDload:
- return rewriteValuePPC64_OpPPC64MOVDload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVDload(v)
case OpPPC64MOVDloadidx:
- return rewriteValuePPC64_OpPPC64MOVDloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVDloadidx(v)
case OpPPC64MOVDstore:
- return rewriteValuePPC64_OpPPC64MOVDstore_0(v)
+ return rewriteValuePPC64_OpPPC64MOVDstore(v)
case OpPPC64MOVDstoreidx:
- return rewriteValuePPC64_OpPPC64MOVDstoreidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVDstoreidx(v)
case OpPPC64MOVDstorezero:
- return rewriteValuePPC64_OpPPC64MOVDstorezero_0(v)
+ return rewriteValuePPC64_OpPPC64MOVDstorezero(v)
case OpPPC64MOVHBRstore:
- return rewriteValuePPC64_OpPPC64MOVHBRstore_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHBRstore(v)
case OpPPC64MOVHZload:
- return rewriteValuePPC64_OpPPC64MOVHZload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHZload(v)
case OpPPC64MOVHZloadidx:
- return rewriteValuePPC64_OpPPC64MOVHZloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHZloadidx(v)
case OpPPC64MOVHZreg:
- return rewriteValuePPC64_OpPPC64MOVHZreg_0(v) || rewriteValuePPC64_OpPPC64MOVHZreg_10(v)
+ return rewriteValuePPC64_OpPPC64MOVHZreg(v)
case OpPPC64MOVHload:
- return rewriteValuePPC64_OpPPC64MOVHload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHload(v)
case OpPPC64MOVHloadidx:
- return rewriteValuePPC64_OpPPC64MOVHloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHloadidx(v)
case OpPPC64MOVHreg:
- return rewriteValuePPC64_OpPPC64MOVHreg_0(v) || rewriteValuePPC64_OpPPC64MOVHreg_10(v)
+ return rewriteValuePPC64_OpPPC64MOVHreg(v)
case OpPPC64MOVHstore:
- return rewriteValuePPC64_OpPPC64MOVHstore_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHstore(v)
case OpPPC64MOVHstoreidx:
- return rewriteValuePPC64_OpPPC64MOVHstoreidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHstoreidx(v)
case OpPPC64MOVHstorezero:
- return rewriteValuePPC64_OpPPC64MOVHstorezero_0(v)
+ return rewriteValuePPC64_OpPPC64MOVHstorezero(v)
case OpPPC64MOVWBRstore:
- return rewriteValuePPC64_OpPPC64MOVWBRstore_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWBRstore(v)
case OpPPC64MOVWZload:
- return rewriteValuePPC64_OpPPC64MOVWZload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWZload(v)
case OpPPC64MOVWZloadidx:
- return rewriteValuePPC64_OpPPC64MOVWZloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWZloadidx(v)
case OpPPC64MOVWZreg:
- return rewriteValuePPC64_OpPPC64MOVWZreg_0(v) || rewriteValuePPC64_OpPPC64MOVWZreg_10(v) || rewriteValuePPC64_OpPPC64MOVWZreg_20(v)
+ return rewriteValuePPC64_OpPPC64MOVWZreg(v)
case OpPPC64MOVWload:
- return rewriteValuePPC64_OpPPC64MOVWload_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWload(v)
case OpPPC64MOVWloadidx:
- return rewriteValuePPC64_OpPPC64MOVWloadidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWloadidx(v)
case OpPPC64MOVWreg:
- return rewriteValuePPC64_OpPPC64MOVWreg_0(v) || rewriteValuePPC64_OpPPC64MOVWreg_10(v)
+ return rewriteValuePPC64_OpPPC64MOVWreg(v)
case OpPPC64MOVWstore:
- return rewriteValuePPC64_OpPPC64MOVWstore_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWstore(v)
case OpPPC64MOVWstoreidx:
- return rewriteValuePPC64_OpPPC64MOVWstoreidx_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWstoreidx(v)
case OpPPC64MOVWstorezero:
- return rewriteValuePPC64_OpPPC64MOVWstorezero_0(v)
+ return rewriteValuePPC64_OpPPC64MOVWstorezero(v)
case OpPPC64MTVSRD:
- return rewriteValuePPC64_OpPPC64MTVSRD_0(v)
+ return rewriteValuePPC64_OpPPC64MTVSRD(v)
case OpPPC64MaskIfNotCarry:
- return rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v)
+ return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v)
case OpPPC64NotEqual:
- return rewriteValuePPC64_OpPPC64NotEqual_0(v)
+ return rewriteValuePPC64_OpPPC64NotEqual(v)
case OpPPC64OR:
- return rewriteValuePPC64_OpPPC64OR_0(v) || rewriteValuePPC64_OpPPC64OR_10(v) || rewriteValuePPC64_OpPPC64OR_20(v)
+ return rewriteValuePPC64_OpPPC64OR(v)
case OpPPC64ORN:
- return rewriteValuePPC64_OpPPC64ORN_0(v)
+ return rewriteValuePPC64_OpPPC64ORN(v)
case OpPPC64ORconst:
- return rewriteValuePPC64_OpPPC64ORconst_0(v)
+ return rewriteValuePPC64_OpPPC64ORconst(v)
case OpPPC64ROTL:
- return rewriteValuePPC64_OpPPC64ROTL_0(v)
+ return rewriteValuePPC64_OpPPC64ROTL(v)
case OpPPC64ROTLW:
- return rewriteValuePPC64_OpPPC64ROTLW_0(v)
+ return rewriteValuePPC64_OpPPC64ROTLW(v)
case OpPPC64SUB:
- return rewriteValuePPC64_OpPPC64SUB_0(v)
+ return rewriteValuePPC64_OpPPC64SUB(v)
case OpPPC64XOR:
- return rewriteValuePPC64_OpPPC64XOR_0(v)
+ return rewriteValuePPC64_OpPPC64XOR(v)
case OpPPC64XORconst:
- return rewriteValuePPC64_OpPPC64XORconst_0(v)
+ return rewriteValuePPC64_OpPPC64XORconst(v)
case OpPanicBounds:
- return rewriteValuePPC64_OpPanicBounds_0(v)
+ return rewriteValuePPC64_OpPanicBounds(v)
case OpPopCount16:
- return rewriteValuePPC64_OpPopCount16_0(v)
+ return rewriteValuePPC64_OpPopCount16(v)
case OpPopCount32:
- return rewriteValuePPC64_OpPopCount32_0(v)
+ return rewriteValuePPC64_OpPopCount32(v)
case OpPopCount64:
- return rewriteValuePPC64_OpPopCount64_0(v)
+ return rewriteValuePPC64_OpPopCount64(v)
case OpPopCount8:
- return rewriteValuePPC64_OpPopCount8_0(v)
+ return rewriteValuePPC64_OpPopCount8(v)
case OpRotateLeft16:
- return rewriteValuePPC64_OpRotateLeft16_0(v)
+ return rewriteValuePPC64_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValuePPC64_OpRotateLeft32_0(v)
+ return rewriteValuePPC64_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValuePPC64_OpRotateLeft64_0(v)
+ return rewriteValuePPC64_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValuePPC64_OpRotateLeft8_0(v)
+ return rewriteValuePPC64_OpRotateLeft8(v)
case OpRound:
- return rewriteValuePPC64_OpRound_0(v)
+ return rewriteValuePPC64_OpRound(v)
case OpRound32F:
- return rewriteValuePPC64_OpRound32F_0(v)
+ return rewriteValuePPC64_OpRound32F(v)
case OpRound64F:
- return rewriteValuePPC64_OpRound64F_0(v)
+ return rewriteValuePPC64_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValuePPC64_OpRsh16Ux16_0(v)
+ return rewriteValuePPC64_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValuePPC64_OpRsh16Ux32_0(v)
+ return rewriteValuePPC64_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValuePPC64_OpRsh16Ux64_0(v)
+ return rewriteValuePPC64_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValuePPC64_OpRsh16Ux8_0(v)
+ return rewriteValuePPC64_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValuePPC64_OpRsh16x16_0(v)
+ return rewriteValuePPC64_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValuePPC64_OpRsh16x32_0(v)
+ return rewriteValuePPC64_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValuePPC64_OpRsh16x64_0(v)
+ return rewriteValuePPC64_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValuePPC64_OpRsh16x8_0(v)
+ return rewriteValuePPC64_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValuePPC64_OpRsh32Ux16_0(v)
+ return rewriteValuePPC64_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValuePPC64_OpRsh32Ux32_0(v)
+ return rewriteValuePPC64_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValuePPC64_OpRsh32Ux64_0(v)
+ return rewriteValuePPC64_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValuePPC64_OpRsh32Ux8_0(v)
+ return rewriteValuePPC64_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValuePPC64_OpRsh32x16_0(v)
+ return rewriteValuePPC64_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValuePPC64_OpRsh32x32_0(v)
+ return rewriteValuePPC64_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValuePPC64_OpRsh32x64_0(v)
+ return rewriteValuePPC64_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValuePPC64_OpRsh32x8_0(v)
+ return rewriteValuePPC64_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValuePPC64_OpRsh64Ux16_0(v)
+ return rewriteValuePPC64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValuePPC64_OpRsh64Ux32_0(v)
+ return rewriteValuePPC64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValuePPC64_OpRsh64Ux64_0(v)
+ return rewriteValuePPC64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValuePPC64_OpRsh64Ux8_0(v)
+ return rewriteValuePPC64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValuePPC64_OpRsh64x16_0(v)
+ return rewriteValuePPC64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValuePPC64_OpRsh64x32_0(v)
+ return rewriteValuePPC64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValuePPC64_OpRsh64x64_0(v)
+ return rewriteValuePPC64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValuePPC64_OpRsh64x8_0(v)
+ return rewriteValuePPC64_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValuePPC64_OpRsh8Ux16_0(v)
+ return rewriteValuePPC64_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValuePPC64_OpRsh8Ux32_0(v)
+ return rewriteValuePPC64_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValuePPC64_OpRsh8Ux64_0(v)
+ return rewriteValuePPC64_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValuePPC64_OpRsh8Ux8_0(v)
+ return rewriteValuePPC64_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValuePPC64_OpRsh8x16_0(v)
+ return rewriteValuePPC64_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValuePPC64_OpRsh8x32_0(v)
+ return rewriteValuePPC64_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValuePPC64_OpRsh8x64_0(v)
+ return rewriteValuePPC64_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValuePPC64_OpRsh8x8_0(v)
+ return rewriteValuePPC64_OpRsh8x8(v)
case OpSignExt16to32:
- return rewriteValuePPC64_OpSignExt16to32_0(v)
+ return rewriteValuePPC64_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValuePPC64_OpSignExt16to64_0(v)
+ return rewriteValuePPC64_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValuePPC64_OpSignExt32to64_0(v)
+ return rewriteValuePPC64_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValuePPC64_OpSignExt8to16_0(v)
+ return rewriteValuePPC64_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValuePPC64_OpSignExt8to32_0(v)
+ return rewriteValuePPC64_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValuePPC64_OpSignExt8to64_0(v)
+ return rewriteValuePPC64_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValuePPC64_OpSlicemask_0(v)
+ return rewriteValuePPC64_OpSlicemask(v)
case OpSqrt:
- return rewriteValuePPC64_OpSqrt_0(v)
+ return rewriteValuePPC64_OpSqrt(v)
case OpStaticCall:
- return rewriteValuePPC64_OpStaticCall_0(v)
+ return rewriteValuePPC64_OpStaticCall(v)
case OpStore:
- return rewriteValuePPC64_OpStore_0(v)
+ return rewriteValuePPC64_OpStore(v)
case OpSub16:
- return rewriteValuePPC64_OpSub16_0(v)
+ return rewriteValuePPC64_OpSub16(v)
case OpSub32:
- return rewriteValuePPC64_OpSub32_0(v)
+ return rewriteValuePPC64_OpSub32(v)
case OpSub32F:
- return rewriteValuePPC64_OpSub32F_0(v)
+ return rewriteValuePPC64_OpSub32F(v)
case OpSub64:
- return rewriteValuePPC64_OpSub64_0(v)
+ return rewriteValuePPC64_OpSub64(v)
case OpSub64F:
- return rewriteValuePPC64_OpSub64F_0(v)
+ return rewriteValuePPC64_OpSub64F(v)
case OpSub8:
- return rewriteValuePPC64_OpSub8_0(v)
+ return rewriteValuePPC64_OpSub8(v)
case OpSubPtr:
- return rewriteValuePPC64_OpSubPtr_0(v)
+ return rewriteValuePPC64_OpSubPtr(v)
case OpTrunc:
- return rewriteValuePPC64_OpTrunc_0(v)
+ return rewriteValuePPC64_OpTrunc(v)
case OpTrunc16to8:
- return rewriteValuePPC64_OpTrunc16to8_0(v)
+ return rewriteValuePPC64_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValuePPC64_OpTrunc32to16_0(v)
+ return rewriteValuePPC64_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValuePPC64_OpTrunc32to8_0(v)
+ return rewriteValuePPC64_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValuePPC64_OpTrunc64to16_0(v)
+ return rewriteValuePPC64_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValuePPC64_OpTrunc64to32_0(v)
+ return rewriteValuePPC64_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValuePPC64_OpTrunc64to8_0(v)
+ return rewriteValuePPC64_OpTrunc64to8(v)
case OpWB:
- return rewriteValuePPC64_OpWB_0(v)
+ return rewriteValuePPC64_OpWB(v)
case OpXor16:
- return rewriteValuePPC64_OpXor16_0(v)
+ return rewriteValuePPC64_OpXor16(v)
case OpXor32:
- return rewriteValuePPC64_OpXor32_0(v)
+ return rewriteValuePPC64_OpXor32(v)
case OpXor64:
- return rewriteValuePPC64_OpXor64_0(v)
+ return rewriteValuePPC64_OpXor64(v)
case OpXor8:
- return rewriteValuePPC64_OpXor8_0(v)
+ return rewriteValuePPC64_OpXor8(v)
case OpZero:
- return rewriteValuePPC64_OpZero_0(v) || rewriteValuePPC64_OpZero_10(v)
+ return rewriteValuePPC64_OpZero(v)
case OpZeroExt16to32:
- return rewriteValuePPC64_OpZeroExt16to32_0(v)
+ return rewriteValuePPC64_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValuePPC64_OpZeroExt16to64_0(v)
+ return rewriteValuePPC64_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValuePPC64_OpZeroExt32to64_0(v)
+ return rewriteValuePPC64_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValuePPC64_OpZeroExt8to16_0(v)
+ return rewriteValuePPC64_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValuePPC64_OpZeroExt8to32_0(v)
+ return rewriteValuePPC64_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValuePPC64_OpZeroExt8to64_0(v)
+ return rewriteValuePPC64_OpZeroExt8to64(v)
}
return false
}
-func rewriteValuePPC64_OpAbs_0(v *Value) bool {
+func rewriteValuePPC64_OpAbs(v *Value) bool {
v_0 := v.Args[0]
// match: (Abs x)
// result: (FABS x)
@@ -735,7 +735,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd16_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -749,7 +749,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd32_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -763,7 +763,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd32F_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -777,7 +777,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd64_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -791,7 +791,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd64F_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -805,7 +805,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd64carry_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd64carry(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -822,7 +822,7 @@
return true
}
}
-func rewriteValuePPC64_OpAdd8_0(v *Value) bool {
+func rewriteValuePPC64_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -836,7 +836,7 @@
return true
}
}
-func rewriteValuePPC64_OpAddPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -850,7 +850,7 @@
return true
}
}
-func rewriteValuePPC64_OpAddr_0(v *Value) bool {
+func rewriteValuePPC64_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} base)
@@ -863,7 +863,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd16_0(v *Value) bool {
+func rewriteValuePPC64_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -877,7 +877,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd32_0(v *Value) bool {
+func rewriteValuePPC64_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -891,7 +891,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd64_0(v *Value) bool {
+func rewriteValuePPC64_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -905,7 +905,7 @@
return true
}
}
-func rewriteValuePPC64_OpAnd8_0(v *Value) bool {
+func rewriteValuePPC64_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -919,7 +919,7 @@
return true
}
}
-func rewriteValuePPC64_OpAndB_0(v *Value) bool {
+func rewriteValuePPC64_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -933,7 +933,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -950,7 +950,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -967,7 +967,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -984,7 +984,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1005,7 +1005,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1026,7 +1026,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwapRel32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwapRel32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1047,7 +1047,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1064,7 +1064,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1081,7 +1081,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -1096,7 +1096,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -1111,7 +1111,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -1126,7 +1126,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadAcq32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoadAcq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadAcq32 ptr mem)
@@ -1141,7 +1141,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -1156,7 +1156,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicOr8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1173,7 +1173,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1191,7 +1191,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1209,7 +1209,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStore8_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1227,7 +1227,7 @@
return true
}
}
-func rewriteValuePPC64_OpAtomicStoreRel32_0(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStoreRel32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1245,7 +1245,7 @@
return true
}
}
-func rewriteValuePPC64_OpAvg64u_0(v *Value) bool {
+func rewriteValuePPC64_OpAvg64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1267,7 +1267,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen32_0(v *Value) bool {
+func rewriteValuePPC64_OpBitLen32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1285,7 +1285,7 @@
return true
}
}
-func rewriteValuePPC64_OpBitLen64_0(v *Value) bool {
+func rewriteValuePPC64_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1303,7 +1303,7 @@
return true
}
}
-func rewriteValuePPC64_OpCeil_0(v *Value) bool {
+func rewriteValuePPC64_OpCeil(v *Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (FCEIL x)
@@ -1314,7 +1314,7 @@
return true
}
}
-func rewriteValuePPC64_OpClosureCall_0(v *Value) bool {
+func rewriteValuePPC64_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1333,7 +1333,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom16_0(v *Value) bool {
+func rewriteValuePPC64_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (NOR x x)
@@ -1345,7 +1345,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom32_0(v *Value) bool {
+func rewriteValuePPC64_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (NOR x x)
@@ -1357,7 +1357,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom64_0(v *Value) bool {
+func rewriteValuePPC64_OpCom64(v *Value) bool {
v_0 := v.Args[0]
// match: (Com64 x)
// result: (NOR x x)
@@ -1369,7 +1369,7 @@
return true
}
}
-func rewriteValuePPC64_OpCom8_0(v *Value) bool {
+func rewriteValuePPC64_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (NOR x x)
@@ -1381,7 +1381,7 @@
return true
}
}
-func rewriteValuePPC64_OpCondSelect_0(v *Value) bool {
+func rewriteValuePPC64_OpCondSelect(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1425,7 +1425,7 @@
}
return false
}
-func rewriteValuePPC64_OpConst16_0(v *Value) bool {
+func rewriteValuePPC64_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [val])
for {
@@ -1435,7 +1435,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst32_0(v *Value) bool {
+func rewriteValuePPC64_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [val])
for {
@@ -1445,7 +1445,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst32F_0(v *Value) bool {
+func rewriteValuePPC64_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (FMOVSconst [val])
for {
@@ -1455,7 +1455,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst64_0(v *Value) bool {
+func rewriteValuePPC64_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [val])
for {
@@ -1465,7 +1465,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst64F_0(v *Value) bool {
+func rewriteValuePPC64_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (FMOVDconst [val])
for {
@@ -1475,7 +1475,7 @@
return true
}
}
-func rewriteValuePPC64_OpConst8_0(v *Value) bool {
+func rewriteValuePPC64_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [val])
for {
@@ -1485,7 +1485,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstBool_0(v *Value) bool {
+func rewriteValuePPC64_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVDconst [b])
for {
@@ -1495,7 +1495,7 @@
return true
}
}
-func rewriteValuePPC64_OpConstNil_0(v *Value) bool {
+func rewriteValuePPC64_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -1504,7 +1504,7 @@
return true
}
}
-func rewriteValuePPC64_OpCopysign_0(v *Value) bool {
+func rewriteValuePPC64_OpCopysign(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Copysign x y)
@@ -1518,7 +1518,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz16_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1539,7 +1539,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz32_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1574,7 +1574,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (Ctz32 x)
@@ -1585,7 +1585,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz64_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1616,7 +1616,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64NonZero x)
// result: (Ctz64 x)
@@ -1627,7 +1627,7 @@
return true
}
}
-func rewriteValuePPC64_OpCtz8_0(v *Value) bool {
+func rewriteValuePPC64_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1648,7 +1648,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1663,7 +1663,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1678,7 +1678,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: x
@@ -1690,7 +1690,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1707,7 +1707,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1724,7 +1724,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1739,7 +1739,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (FRSP x)
@@ -1750,7 +1750,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1765,7 +1765,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1780,7 +1780,7 @@
return true
}
}
-func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1795,7 +1795,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv16_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1815,7 +1815,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv16u_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1835,7 +1835,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 x y)
@@ -1849,7 +1849,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32F_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1863,7 +1863,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv32u_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32u x y)
@@ -1877,7 +1877,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1891,7 +1891,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64F_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1905,7 +1905,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv64u_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64u x y)
@@ -1919,7 +1919,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv8_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1939,7 +1939,7 @@
return true
}
}
-func rewriteValuePPC64_OpDiv8u_0(v *Value) bool {
+func rewriteValuePPC64_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1959,7 +1959,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq16_0(v *Value) bool {
+func rewriteValuePPC64_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2004,7 +2004,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32_0(v *Value) bool {
+func rewriteValuePPC64_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2021,7 +2021,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq32F_0(v *Value) bool {
+func rewriteValuePPC64_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2038,7 +2038,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64_0(v *Value) bool {
+func rewriteValuePPC64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2055,7 +2055,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq64F_0(v *Value) bool {
+func rewriteValuePPC64_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2072,7 +2072,7 @@
return true
}
}
-func rewriteValuePPC64_OpEq8_0(v *Value) bool {
+func rewriteValuePPC64_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2117,7 +2117,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqB_0(v *Value) bool {
+func rewriteValuePPC64_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2136,7 +2136,7 @@
return true
}
}
-func rewriteValuePPC64_OpEqPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2153,7 +2153,7 @@
return true
}
}
-func rewriteValuePPC64_OpFMA_0(v *Value) bool {
+func rewriteValuePPC64_OpFMA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2170,7 +2170,7 @@
return true
}
}
-func rewriteValuePPC64_OpFloor_0(v *Value) bool {
+func rewriteValuePPC64_OpFloor(v *Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (FFLOOR x)
@@ -2181,7 +2181,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq16_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2203,7 +2203,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq16U_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2225,7 +2225,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2242,7 +2242,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32F_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2259,7 +2259,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq32U_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2276,7 +2276,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2293,7 +2293,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64F_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2310,7 +2310,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq64U_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2327,7 +2327,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq8_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2349,7 +2349,7 @@
return true
}
}
-func rewriteValuePPC64_OpGeq8U_0(v *Value) bool {
+func rewriteValuePPC64_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2371,7 +2371,7 @@
return true
}
}
-func rewriteValuePPC64_OpGetCallerPC_0(v *Value) bool {
+func rewriteValuePPC64_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -2379,7 +2379,7 @@
return true
}
}
-func rewriteValuePPC64_OpGetCallerSP_0(v *Value) bool {
+func rewriteValuePPC64_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -2387,7 +2387,7 @@
return true
}
}
-func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -2395,7 +2395,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater16_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2417,7 +2417,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater16U_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2439,7 +2439,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2456,7 +2456,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32F_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2473,7 +2473,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater32U_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2490,7 +2490,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2507,7 +2507,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64F_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2524,7 +2524,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater64U_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2541,7 +2541,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater8_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2563,7 +2563,7 @@
return true
}
}
-func rewriteValuePPC64_OpGreater8U_0(v *Value) bool {
+func rewriteValuePPC64_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2585,7 +2585,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul32_0(v *Value) bool {
+func rewriteValuePPC64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32 x y)
@@ -2599,7 +2599,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul32u_0(v *Value) bool {
+func rewriteValuePPC64_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul32u x y)
@@ -2613,7 +2613,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul64_0(v *Value) bool {
+func rewriteValuePPC64_OpHmul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64 x y)
@@ -2627,7 +2627,7 @@
return true
}
}
-func rewriteValuePPC64_OpHmul64u_0(v *Value) bool {
+func rewriteValuePPC64_OpHmul64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64u x y)
@@ -2641,7 +2641,7 @@
return true
}
}
-func rewriteValuePPC64_OpInterCall_0(v *Value) bool {
+func rewriteValuePPC64_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -2657,7 +2657,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool {
+func rewriteValuePPC64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2674,7 +2674,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool {
+func rewriteValuePPC64_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (IsNonNil ptr)
@@ -2689,7 +2689,7 @@
return true
}
}
-func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2706,7 +2706,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2728,7 +2728,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq16U_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2750,7 +2750,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2767,7 +2767,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32F_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2784,7 +2784,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq32U_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2801,7 +2801,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2818,7 +2818,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64F_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2835,7 +2835,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq64U_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2852,7 +2852,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2874,7 +2874,7 @@
return true
}
}
-func rewriteValuePPC64_OpLeq8U_0(v *Value) bool {
+func rewriteValuePPC64_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2896,7 +2896,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16_0(v *Value) bool {
+func rewriteValuePPC64_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2918,7 +2918,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess16U_0(v *Value) bool {
+func rewriteValuePPC64_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2940,7 +2940,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32_0(v *Value) bool {
+func rewriteValuePPC64_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2957,7 +2957,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32F_0(v *Value) bool {
+func rewriteValuePPC64_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2974,7 +2974,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess32U_0(v *Value) bool {
+func rewriteValuePPC64_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2991,7 +2991,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64_0(v *Value) bool {
+func rewriteValuePPC64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3008,7 +3008,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64F_0(v *Value) bool {
+func rewriteValuePPC64_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3025,7 +3025,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess64U_0(v *Value) bool {
+func rewriteValuePPC64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3042,7 +3042,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8_0(v *Value) bool {
+func rewriteValuePPC64_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3064,7 +3064,7 @@
return true
}
}
-func rewriteValuePPC64_OpLess8U_0(v *Value) bool {
+func rewriteValuePPC64_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3086,7 +3086,7 @@
return true
}
}
-func rewriteValuePPC64_OpLoad_0(v *Value) bool {
+func rewriteValuePPC64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3245,7 +3245,7 @@
}
return false
}
-func rewriteValuePPC64_OpLocalAddr_0(v *Value) bool {
+func rewriteValuePPC64_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVDaddr {sym} base)
@@ -3258,7 +3258,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3298,7 +3298,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3372,7 +3372,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3459,7 +3459,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3499,7 +3499,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3539,7 +3539,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3613,7 +3613,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3741,7 +3741,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3781,7 +3781,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3821,7 +3821,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3895,7 +3895,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4023,7 +4023,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4063,7 +4063,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4103,7 +4103,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4177,7 +4177,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4264,7 +4264,7 @@
return true
}
}
-func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4304,7 +4304,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod16_0(v *Value) bool {
+func rewriteValuePPC64_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4324,7 +4324,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod16u_0(v *Value) bool {
+func rewriteValuePPC64_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4344,7 +4344,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod32_0(v *Value) bool {
+func rewriteValuePPC64_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4366,7 +4366,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod32u_0(v *Value) bool {
+func rewriteValuePPC64_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4388,7 +4388,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod64_0(v *Value) bool {
+func rewriteValuePPC64_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4410,7 +4410,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod64u_0(v *Value) bool {
+func rewriteValuePPC64_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4432,7 +4432,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod8_0(v *Value) bool {
+func rewriteValuePPC64_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4452,7 +4452,7 @@
return true
}
}
-func rewriteValuePPC64_OpMod8u_0(v *Value) bool {
+func rewriteValuePPC64_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4472,7 +4472,7 @@
return true
}
}
-func rewriteValuePPC64_OpMove_0(v *Value) bool {
+func rewriteValuePPC64_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4711,12 +4711,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValuePPC64_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (Move [s] dst src mem)
// cond: s > 8
// result: (LoweredMove [s] dst src mem)
@@ -4737,7 +4731,7 @@
}
return false
}
-func rewriteValuePPC64_OpMul16_0(v *Value) bool {
+func rewriteValuePPC64_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -4751,7 +4745,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul32_0(v *Value) bool {
+func rewriteValuePPC64_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -4765,7 +4759,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul32F_0(v *Value) bool {
+func rewriteValuePPC64_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -4779,7 +4773,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul64_0(v *Value) bool {
+func rewriteValuePPC64_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64 x y)
@@ -4793,7 +4787,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul64F_0(v *Value) bool {
+func rewriteValuePPC64_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -4807,7 +4801,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul64uhilo_0(v *Value) bool {
+func rewriteValuePPC64_OpMul64uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64uhilo x y)
@@ -4821,7 +4815,7 @@
return true
}
}
-func rewriteValuePPC64_OpMul8_0(v *Value) bool {
+func rewriteValuePPC64_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -4835,7 +4829,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg16_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEG x)
@@ -4846,7 +4840,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg32_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEG x)
@@ -4857,7 +4851,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg32F_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (FNEG x)
@@ -4868,7 +4862,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg64_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64 x)
// result: (NEG x)
@@ -4879,7 +4873,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg64F_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (FNEG x)
@@ -4890,7 +4884,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeg8_0(v *Value) bool {
+func rewriteValuePPC64_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEG x)
@@ -4901,7 +4895,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq16_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4946,7 +4940,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4963,7 +4957,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq32F_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4980,7 +4974,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4997,7 +4991,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq64F_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5014,7 +5008,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeq8_0(v *Value) bool {
+func rewriteValuePPC64_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5059,7 +5053,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeqB_0(v *Value) bool {
+func rewriteValuePPC64_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -5073,7 +5067,7 @@
return true
}
}
-func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5090,7 +5084,7 @@
return true
}
}
-func rewriteValuePPC64_OpNilCheck_0(v *Value) bool {
+func rewriteValuePPC64_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -5104,7 +5098,7 @@
return true
}
}
-func rewriteValuePPC64_OpNot_0(v *Value) bool {
+func rewriteValuePPC64_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORconst [1] x)
@@ -5116,7 +5110,7 @@
return true
}
}
-func rewriteValuePPC64_OpOffPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5133,7 +5127,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr16_0(v *Value) bool {
+func rewriteValuePPC64_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -5147,7 +5141,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr32_0(v *Value) bool {
+func rewriteValuePPC64_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -5161,7 +5155,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr64_0(v *Value) bool {
+func rewriteValuePPC64_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -5175,7 +5169,7 @@
return true
}
}
-func rewriteValuePPC64_OpOr8_0(v *Value) bool {
+func rewriteValuePPC64_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -5189,7 +5183,7 @@
return true
}
}
-func rewriteValuePPC64_OpOrB_0(v *Value) bool {
+func rewriteValuePPC64_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -5203,7 +5197,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5360,7 +5354,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [c] (ADDconst [d] x))
// cond: is32Bit(c+d)
@@ -5410,7 +5404,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64AND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AND x (NOR y y))
@@ -5530,7 +5524,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [c] (ANDconst [d] x))
// result: (ANDconst [c&d] x)
@@ -5665,10 +5659,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64ANDconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (ANDconst [c] (MOVHZreg x))
// result: (ANDconst [c&0xFFFF] x)
for {
@@ -5710,7 +5700,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5752,7 +5742,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5794,7 +5784,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: x==y
@@ -5843,7 +5833,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5911,7 +5901,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5979,7 +5969,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -6028,7 +6018,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -6077,7 +6067,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
@@ -6126,7 +6116,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64Equal(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6184,7 +6174,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FABS_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FABS(v *Value) bool {
v_0 := v.Args[0]
// match: (FABS (FMOVDconst [x]))
// result: (FMOVDconst [auxFrom64F(math.Abs(auxTo64F(x)))])
@@ -6199,7 +6189,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADD (FMUL x y) z)
@@ -6222,7 +6212,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS (FMULS x y) z)
@@ -6245,7 +6235,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FCEIL_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FCEIL(v *Value) bool {
v_0 := v.Args[0]
// match: (FCEIL (FMOVDconst [x]))
// result: (FMOVDconst [auxFrom64F(math.Ceil(auxTo64F(x)))])
@@ -6260,7 +6250,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FFLOOR_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FFLOOR(v *Value) bool {
v_0 := v.Args[0]
// match: (FFLOOR (FMOVDconst [x]))
// result: (FMOVDconst [auxFrom64F(math.Floor(auxTo64F(x)))])
@@ -6275,7 +6265,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FGreaterEqual_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FGreaterEqual(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6299,7 +6289,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FGreaterThan_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FGreaterThan(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6316,7 +6306,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FLessEqual_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FLessEqual(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6340,7 +6330,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FLessThan_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FLessThan(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6357,7 +6347,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVDload [off] {sym} ptr (MOVDstore [off] {sym} ptr x _))
@@ -6426,7 +6416,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6501,7 +6491,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVSload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -6552,7 +6542,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6608,7 +6598,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FNEG_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FNEG(v *Value) bool {
v_0 := v.Args[0]
// match: (FNEG (FABS x))
// result: (FNABS x)
@@ -6634,7 +6624,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSQRT_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSQRT(v *Value) bool {
v_0 := v.Args[0]
// match: (FSQRT (FMOVDconst [x]))
// result: (FMOVDconst [auxFrom64F(math.Sqrt(auxTo64F(x)))])
@@ -6649,7 +6639,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUB (FMUL x y) z)
@@ -6669,7 +6659,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS (FMULS x y) z)
@@ -6689,7 +6679,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64FTRUNC_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FTRUNC(v *Value) bool {
v_0 := v.Args[0]
// match: (FTRUNC (FMOVDconst [x]))
// result: (FMOVDconst [auxFrom64F(math.Trunc(auxTo64F(x)))])
@@ -6704,7 +6694,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6762,7 +6752,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6820,7 +6810,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64ISEL_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ISEL(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6974,12 +6964,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64ISEL_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (ISEL [5] _ x (FlagLT))
// result: x
for {
@@ -7142,12 +7126,6 @@
v.AddArg(bool)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64ISEL_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (ISEL [n] x y (InvertFlags bool))
// cond: n%4 == 2
// result: (ISEL [n] x y bool)
@@ -7171,8 +7149,11 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ISELB_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ISELB(v *Value) bool {
v_1 := v.Args[1]
+ v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (ISELB [0] _ (FlagLT))
// result: (MOVDconst [1])
for {
@@ -7273,13 +7254,6 @@
v.AuxInt = 0
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64ISELB_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ISELB [4] _ (FlagGT))
// result: (MOVDconst [1])
for {
@@ -7400,13 +7374,6 @@
v.AddArg(bool)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64ISELB_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ISELB [n] (MOVDconst [1]) (InvertFlags bool))
// cond: n%4 == 2
// result: (ISELB [n] (MOVDconst [1]) bool)
@@ -7429,7 +7396,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7487,7 +7454,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7545,7 +7512,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64MFVSRD_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MFVSRD(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7587,7 +7554,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -7662,7 +7629,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7706,7 +7673,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -7863,10 +7830,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVBZreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVBZreg (MOVDconst [c]))
// result: (MOVDconst [int64(uint8(c))])
for {
@@ -7880,7 +7843,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -8045,10 +8008,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVBreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVBreg (MOVDconst [c]))
// result: (MOVDconst [int64(int8(c))])
for {
@@ -8062,10 +8021,13 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ config := b.Func.Config
+ typ := &b.Func.Config.Types
// match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVBstore [off1+off2] {sym} x val mem)
@@ -8271,15 +8233,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVBstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (MOVBstore [off] {sym} ptr (SRWconst (MOVHreg x) [c]) mem)
// cond: c <= 8
// result: (MOVBstore [off] {sym} ptr (SRWconst <typ.UInt32> x [c]) mem)
@@ -8642,15 +8595,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVBstore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (MOVBstore [i7] {s} p (SRDconst w [56]) x0:(MOVBstore [i6] {s} p (SRDconst w [48]) x1:(MOVBstore [i5] {s} p (SRDconst w [40]) x2:(MOVBstore [i4] {s} p (SRDconst w [32]) x3:(MOVWstore [i0] {s} p w mem)))))
// cond: !config.BigEndian && i0%4 == 0 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3)
// result: (MOVDstore [i0] {s} p w mem)
@@ -8862,7 +8806,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstoreidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9103,15 +9047,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVBstoreidx_10(v *Value) bool {
- v_3 := v.Args[3]
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVBstoreidx [off] {sym} ptr idx (SRWconst (MOVWreg x) [c]) mem)
// cond: c <= 24
// result: (MOVBstoreidx [off] {sym} ptr idx (SRWconst <typ.UInt32> x [c]) mem)
@@ -9180,7 +9115,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -9231,7 +9166,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off] {sym} ptr (FMOVDstore [off] {sym} ptr x _))
@@ -9324,7 +9259,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9368,7 +9303,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9484,7 +9419,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstoreidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9533,7 +9468,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -9584,7 +9519,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHBRstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHBRstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9658,7 +9593,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -9733,7 +9668,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9777,7 +9712,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -9936,10 +9871,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVHZreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVHZreg x:(MOVBZload _ _))
// result: x
for {
@@ -10022,7 +9953,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -10097,7 +10028,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10141,7 +10072,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -10309,10 +10240,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVHreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVHreg y:(MOVHZreg x))
// result: (MOVHreg x)
for {
@@ -10381,7 +10308,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10618,7 +10545,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstoreidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -10751,7 +10678,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -10802,7 +10729,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWBRstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWBRstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10842,7 +10769,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWZload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -10917,7 +10844,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10961,7 +10888,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11135,10 +11062,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVWZreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVWZreg y:(MOVHBRload _ _))
// result: y
for {
@@ -11272,10 +11195,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVWZreg_20(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVWZreg (MOVDconst [c]))
// result: (MOVDconst [int64(uint32(c))])
for {
@@ -11289,7 +11208,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off1] {sym1} p:(MOVDaddr [off2] {sym2} ptr) mem)
@@ -11364,7 +11283,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWloadidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11408,7 +11327,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -11587,10 +11506,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuePPC64_OpPPC64MOVWreg_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (MOVWreg y:(MOVBreg _))
// result: y
for {
@@ -11697,7 +11612,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11832,7 +11747,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstoreidx_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -11923,7 +11838,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
@@ -11974,7 +11889,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MTVSRD_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MTVSRD(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -12016,7 +11931,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool {
v_0 := v.Args[0]
// match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _)))
// cond: c < 0 && d > 0 && c + d < 0
@@ -12040,7 +11955,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -12098,7 +12013,7 @@
return true
}
}
-func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -12444,14 +12359,6 @@
}
break
}
- return false
-}
-func rewriteValuePPC64_OpPPC64OR_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (OR <t> s0:(SLWconst x0:(MOVBZload [i1] {s} p mem) [n1]) s1:(SLWconst x1:(MOVBZload [i0] {s} p mem) [n2]))
// cond: !config.BigEndian && i1 == i0+1 && n1%8 == 0 && n2 == n1+8 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && mergePoint(b, x0, x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1)
// result: @mergePoint(b,x0,x1) (SLDconst <t> (MOVHBRload <t> (MOVDaddr <typ.Uintptr> [i0] {s} p) mem) [n1])
@@ -13126,14 +13033,6 @@
}
break
}
- return false
-}
-func rewriteValuePPC64_OpPPC64OR_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- typ := &b.Func.Config.Types
// match: (OR <t> s6:(SLDconst x7:(MOVBZload [i7] {s} p mem) [56]) o5:(OR <t> s5:(SLDconst x6:(MOVBZload [i6] {s} p mem) [48]) o4:(OR <t> s4:(SLDconst x5:(MOVBZload [i5] {s} p mem) [40]) o3:(OR <t> s3:(SLDconst x4:(MOVBZload [i4] {s} p mem) [32]) x0:(MOVWZload {s} [i0] p mem)))))
// cond: !config.BigEndian && i0%4 == 0 && i4 == i0+4 && i5 == i0+5 && i6 == i0+6 && i7 == i0+7 && x0.Uses == 1 && x4.Uses == 1 && x5.Uses == 1 && x6.Uses ==1 && x7.Uses == 1 && o3.Uses == 1 && o4.Uses == 1 && o5.Uses == 1 && s3.Uses == 1 && s4.Uses == 1 && s5.Uses == 1 && s6.Uses == 1 && mergePoint(b, x0, x4, x5, x6, x7) != nil && clobber(x0) && clobber(x4) && clobber(x5) && clobber(x6) && clobber(x7) && clobber(s3) && clobber(s4) && clobber(s5) && clobber (s6) && clobber(o3) && clobber(o4) && clobber(o5)
// result: @mergePoint(b,x0,x4,x5,x6,x7) (MOVDload <t> {s} [i0] p mem)
@@ -13613,7 +13512,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORN(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ORN x (MOVDconst [-1]))
@@ -13630,7 +13529,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [c] (ORconst [d] x))
// result: (ORconst [c|d] x)
@@ -13670,7 +13569,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ROTL_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ROTL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTL x (MOVDconst [c]))
@@ -13688,7 +13587,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64ROTLW_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ROTLW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ROTLW x (MOVDconst [c]))
@@ -13706,7 +13605,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64SUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SUB x (MOVDconst [c]))
@@ -13728,7 +13627,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13903,7 +13802,7 @@
}
return false
}
-func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [c] (XORconst [d] x))
// result: (XORconst [c^d] x)
@@ -13933,7 +13832,7 @@
}
return false
}
-func rewriteValuePPC64_OpPanicBounds_0(v *Value) bool {
+func rewriteValuePPC64_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13993,7 +13892,7 @@
}
return false
}
-func rewriteValuePPC64_OpPopCount16_0(v *Value) bool {
+func rewriteValuePPC64_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14008,7 +13907,7 @@
return true
}
}
-func rewriteValuePPC64_OpPopCount32_0(v *Value) bool {
+func rewriteValuePPC64_OpPopCount32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14023,7 +13922,7 @@
return true
}
}
-func rewriteValuePPC64_OpPopCount64_0(v *Value) bool {
+func rewriteValuePPC64_OpPopCount64(v *Value) bool {
v_0 := v.Args[0]
// match: (PopCount64 x)
// result: (POPCNTD x)
@@ -14034,7 +13933,7 @@
return true
}
}
-func rewriteValuePPC64_OpPopCount8_0(v *Value) bool {
+func rewriteValuePPC64_OpPopCount8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -14049,7 +13948,7 @@
return true
}
}
-func rewriteValuePPC64_OpRotateLeft16_0(v *Value) bool {
+func rewriteValuePPC64_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14080,7 +13979,7 @@
}
return false
}
-func rewriteValuePPC64_OpRotateLeft32_0(v *Value) bool {
+func rewriteValuePPC64_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x (MOVDconst [c]))
@@ -14107,7 +14006,7 @@
return true
}
}
-func rewriteValuePPC64_OpRotateLeft64_0(v *Value) bool {
+func rewriteValuePPC64_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft64 x (MOVDconst [c]))
@@ -14134,7 +14033,7 @@
return true
}
}
-func rewriteValuePPC64_OpRotateLeft8_0(v *Value) bool {
+func rewriteValuePPC64_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14165,7 +14064,7 @@
}
return false
}
-func rewriteValuePPC64_OpRound_0(v *Value) bool {
+func rewriteValuePPC64_OpRound(v *Value) bool {
v_0 := v.Args[0]
// match: (Round x)
// result: (FROUND x)
@@ -14176,7 +14075,7 @@
return true
}
}
-func rewriteValuePPC64_OpRound32F_0(v *Value) bool {
+func rewriteValuePPC64_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: (LoweredRound32F x)
@@ -14187,7 +14086,7 @@
return true
}
}
-func rewriteValuePPC64_OpRound64F_0(v *Value) bool {
+func rewriteValuePPC64_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: (LoweredRound64F x)
@@ -14198,7 +14097,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14242,7 +14141,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14324,7 +14223,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14419,7 +14318,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14463,7 +14362,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14507,7 +14406,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14589,7 +14488,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14688,7 +14587,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14732,7 +14631,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14772,7 +14671,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14846,7 +14745,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15043,7 +14942,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15083,7 +14982,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15123,7 +15022,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15197,7 +15096,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15396,7 +15295,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15436,7 +15335,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15476,7 +15375,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15550,7 +15449,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15747,7 +15646,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15787,7 +15686,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15827,7 +15726,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15901,7 +15800,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16100,7 +15999,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16140,7 +16039,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16184,7 +16083,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16266,7 +16165,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16361,7 +16260,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16405,7 +16304,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16449,7 +16348,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16531,7 +16430,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16630,7 +16529,7 @@
return true
}
}
-func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16674,7 +16573,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -16685,7 +16584,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 x)
// result: (MOVHreg x)
@@ -16696,7 +16595,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 x)
// result: (MOVWreg x)
@@ -16707,7 +16606,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -16718,7 +16617,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -16729,7 +16628,7 @@
return true
}
}
-func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 x)
// result: (MOVBreg x)
@@ -16740,7 +16639,7 @@
return true
}
}
-func rewriteValuePPC64_OpSlicemask_0(v *Value) bool {
+func rewriteValuePPC64_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -16756,7 +16655,7 @@
return true
}
}
-func rewriteValuePPC64_OpSqrt_0(v *Value) bool {
+func rewriteValuePPC64_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (FSQRT x)
@@ -16767,7 +16666,7 @@
return true
}
}
-func rewriteValuePPC64_OpStaticCall_0(v *Value) bool {
+func rewriteValuePPC64_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -16782,7 +16681,7 @@
return true
}
}
-func rewriteValuePPC64_OpStore_0(v *Value) bool {
+func rewriteValuePPC64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16907,7 +16806,7 @@
}
return false
}
-func rewriteValuePPC64_OpSub16_0(v *Value) bool {
+func rewriteValuePPC64_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -16921,7 +16820,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub32_0(v *Value) bool {
+func rewriteValuePPC64_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -16935,7 +16834,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub32F_0(v *Value) bool {
+func rewriteValuePPC64_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -16949,7 +16848,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub64_0(v *Value) bool {
+func rewriteValuePPC64_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -16963,7 +16862,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub64F_0(v *Value) bool {
+func rewriteValuePPC64_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -16977,7 +16876,7 @@
return true
}
}
-func rewriteValuePPC64_OpSub8_0(v *Value) bool {
+func rewriteValuePPC64_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -16991,7 +16890,7 @@
return true
}
}
-func rewriteValuePPC64_OpSubPtr_0(v *Value) bool {
+func rewriteValuePPC64_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -17005,7 +16904,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (FTRUNC x)
@@ -17016,7 +16915,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 <t> x)
// cond: isSigned(t)
@@ -17040,7 +16939,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 <t> x)
// cond: isSigned(t)
@@ -17064,7 +16963,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 <t> x)
// cond: isSigned(t)
@@ -17088,7 +16987,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 <t> x)
// cond: isSigned(t)
@@ -17112,7 +17011,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 <t> x)
// cond: isSigned(t)
@@ -17136,7 +17035,7 @@
return true
}
}
-func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 <t> x)
// cond: isSigned(t)
@@ -17160,7 +17059,7 @@
return true
}
}
-func rewriteValuePPC64_OpWB_0(v *Value) bool {
+func rewriteValuePPC64_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -17179,7 +17078,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor16_0(v *Value) bool {
+func rewriteValuePPC64_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -17193,7 +17092,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor32_0(v *Value) bool {
+func rewriteValuePPC64_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -17207,7 +17106,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor64_0(v *Value) bool {
+func rewriteValuePPC64_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -17221,7 +17120,7 @@
return true
}
}
-func rewriteValuePPC64_OpXor8_0(v *Value) bool {
+func rewriteValuePPC64_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -17235,7 +17134,7 @@
return true
}
}
-func rewriteValuePPC64_OpZero_0(v *Value) bool {
+func rewriteValuePPC64_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17398,12 +17297,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValuePPC64_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (Zero [12] {t} destptr mem)
// cond: t.(*types.Type).Alignment()%4 == 0
// result: (MOVWstorezero [8] destptr (MOVDstorezero [0] destptr mem))
@@ -17521,7 +17414,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHZreg x)
@@ -17532,7 +17425,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 x)
// result: (MOVHZreg x)
@@ -17543,7 +17436,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 x)
// result: (MOVWZreg x)
@@ -17554,7 +17447,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBZreg x)
@@ -17565,7 +17458,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBZreg x)
@@ -17576,7 +17469,7 @@
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 x)
// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteRISCV64.go b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
index 5e5c472..d7b92c5 100644
--- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go
+++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go
@@ -9,509 +9,509 @@
func rewriteValueRISCV64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueRISCV64_OpAdd16_0(v)
+ return rewriteValueRISCV64_OpAdd16(v)
case OpAdd32:
- return rewriteValueRISCV64_OpAdd32_0(v)
+ return rewriteValueRISCV64_OpAdd32(v)
case OpAdd32F:
- return rewriteValueRISCV64_OpAdd32F_0(v)
+ return rewriteValueRISCV64_OpAdd32F(v)
case OpAdd64:
- return rewriteValueRISCV64_OpAdd64_0(v)
+ return rewriteValueRISCV64_OpAdd64(v)
case OpAdd64F:
- return rewriteValueRISCV64_OpAdd64F_0(v)
+ return rewriteValueRISCV64_OpAdd64F(v)
case OpAdd8:
- return rewriteValueRISCV64_OpAdd8_0(v)
+ return rewriteValueRISCV64_OpAdd8(v)
case OpAddPtr:
- return rewriteValueRISCV64_OpAddPtr_0(v)
+ return rewriteValueRISCV64_OpAddPtr(v)
case OpAddr:
- return rewriteValueRISCV64_OpAddr_0(v)
+ return rewriteValueRISCV64_OpAddr(v)
case OpAnd16:
- return rewriteValueRISCV64_OpAnd16_0(v)
+ return rewriteValueRISCV64_OpAnd16(v)
case OpAnd32:
- return rewriteValueRISCV64_OpAnd32_0(v)
+ return rewriteValueRISCV64_OpAnd32(v)
case OpAnd64:
- return rewriteValueRISCV64_OpAnd64_0(v)
+ return rewriteValueRISCV64_OpAnd64(v)
case OpAnd8:
- return rewriteValueRISCV64_OpAnd8_0(v)
+ return rewriteValueRISCV64_OpAnd8(v)
case OpAndB:
- return rewriteValueRISCV64_OpAndB_0(v)
+ return rewriteValueRISCV64_OpAndB(v)
case OpAvg64u:
- return rewriteValueRISCV64_OpAvg64u_0(v)
+ return rewriteValueRISCV64_OpAvg64u(v)
case OpClosureCall:
- return rewriteValueRISCV64_OpClosureCall_0(v)
+ return rewriteValueRISCV64_OpClosureCall(v)
case OpCom16:
- return rewriteValueRISCV64_OpCom16_0(v)
+ return rewriteValueRISCV64_OpCom16(v)
case OpCom32:
- return rewriteValueRISCV64_OpCom32_0(v)
+ return rewriteValueRISCV64_OpCom32(v)
case OpCom64:
- return rewriteValueRISCV64_OpCom64_0(v)
+ return rewriteValueRISCV64_OpCom64(v)
case OpCom8:
- return rewriteValueRISCV64_OpCom8_0(v)
+ return rewriteValueRISCV64_OpCom8(v)
case OpConst16:
- return rewriteValueRISCV64_OpConst16_0(v)
+ return rewriteValueRISCV64_OpConst16(v)
case OpConst32:
- return rewriteValueRISCV64_OpConst32_0(v)
+ return rewriteValueRISCV64_OpConst32(v)
case OpConst32F:
- return rewriteValueRISCV64_OpConst32F_0(v)
+ return rewriteValueRISCV64_OpConst32F(v)
case OpConst64:
- return rewriteValueRISCV64_OpConst64_0(v)
+ return rewriteValueRISCV64_OpConst64(v)
case OpConst64F:
- return rewriteValueRISCV64_OpConst64F_0(v)
+ return rewriteValueRISCV64_OpConst64F(v)
case OpConst8:
- return rewriteValueRISCV64_OpConst8_0(v)
+ return rewriteValueRISCV64_OpConst8(v)
case OpConstBool:
- return rewriteValueRISCV64_OpConstBool_0(v)
+ return rewriteValueRISCV64_OpConstBool(v)
case OpConstNil:
- return rewriteValueRISCV64_OpConstNil_0(v)
+ return rewriteValueRISCV64_OpConstNil(v)
case OpConvert:
- return rewriteValueRISCV64_OpConvert_0(v)
+ return rewriteValueRISCV64_OpConvert(v)
case OpCvt32Fto32:
- return rewriteValueRISCV64_OpCvt32Fto32_0(v)
+ return rewriteValueRISCV64_OpCvt32Fto32(v)
case OpCvt32Fto64:
- return rewriteValueRISCV64_OpCvt32Fto64_0(v)
+ return rewriteValueRISCV64_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValueRISCV64_OpCvt32Fto64F_0(v)
+ return rewriteValueRISCV64_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValueRISCV64_OpCvt32to32F_0(v)
+ return rewriteValueRISCV64_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueRISCV64_OpCvt32to64F_0(v)
+ return rewriteValueRISCV64_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueRISCV64_OpCvt64Fto32_0(v)
+ return rewriteValueRISCV64_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueRISCV64_OpCvt64Fto32F_0(v)
+ return rewriteValueRISCV64_OpCvt64Fto32F(v)
case OpCvt64Fto64:
- return rewriteValueRISCV64_OpCvt64Fto64_0(v)
+ return rewriteValueRISCV64_OpCvt64Fto64(v)
case OpCvt64to32F:
- return rewriteValueRISCV64_OpCvt64to32F_0(v)
+ return rewriteValueRISCV64_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValueRISCV64_OpCvt64to64F_0(v)
+ return rewriteValueRISCV64_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValueRISCV64_OpDiv16_0(v)
+ return rewriteValueRISCV64_OpDiv16(v)
case OpDiv16u:
- return rewriteValueRISCV64_OpDiv16u_0(v)
+ return rewriteValueRISCV64_OpDiv16u(v)
case OpDiv32:
- return rewriteValueRISCV64_OpDiv32_0(v)
+ return rewriteValueRISCV64_OpDiv32(v)
case OpDiv32F:
- return rewriteValueRISCV64_OpDiv32F_0(v)
+ return rewriteValueRISCV64_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueRISCV64_OpDiv32u_0(v)
+ return rewriteValueRISCV64_OpDiv32u(v)
case OpDiv64:
- return rewriteValueRISCV64_OpDiv64_0(v)
+ return rewriteValueRISCV64_OpDiv64(v)
case OpDiv64F:
- return rewriteValueRISCV64_OpDiv64F_0(v)
+ return rewriteValueRISCV64_OpDiv64F(v)
case OpDiv64u:
- return rewriteValueRISCV64_OpDiv64u_0(v)
+ return rewriteValueRISCV64_OpDiv64u(v)
case OpDiv8:
- return rewriteValueRISCV64_OpDiv8_0(v)
+ return rewriteValueRISCV64_OpDiv8(v)
case OpDiv8u:
- return rewriteValueRISCV64_OpDiv8u_0(v)
+ return rewriteValueRISCV64_OpDiv8u(v)
case OpEq16:
- return rewriteValueRISCV64_OpEq16_0(v)
+ return rewriteValueRISCV64_OpEq16(v)
case OpEq32:
- return rewriteValueRISCV64_OpEq32_0(v)
+ return rewriteValueRISCV64_OpEq32(v)
case OpEq32F:
- return rewriteValueRISCV64_OpEq32F_0(v)
+ return rewriteValueRISCV64_OpEq32F(v)
case OpEq64:
- return rewriteValueRISCV64_OpEq64_0(v)
+ return rewriteValueRISCV64_OpEq64(v)
case OpEq64F:
- return rewriteValueRISCV64_OpEq64F_0(v)
+ return rewriteValueRISCV64_OpEq64F(v)
case OpEq8:
- return rewriteValueRISCV64_OpEq8_0(v)
+ return rewriteValueRISCV64_OpEq8(v)
case OpEqB:
- return rewriteValueRISCV64_OpEqB_0(v)
+ return rewriteValueRISCV64_OpEqB(v)
case OpEqPtr:
- return rewriteValueRISCV64_OpEqPtr_0(v)
+ return rewriteValueRISCV64_OpEqPtr(v)
case OpGeq16:
- return rewriteValueRISCV64_OpGeq16_0(v)
+ return rewriteValueRISCV64_OpGeq16(v)
case OpGeq16U:
- return rewriteValueRISCV64_OpGeq16U_0(v)
+ return rewriteValueRISCV64_OpGeq16U(v)
case OpGeq32:
- return rewriteValueRISCV64_OpGeq32_0(v)
+ return rewriteValueRISCV64_OpGeq32(v)
case OpGeq32F:
- return rewriteValueRISCV64_OpGeq32F_0(v)
+ return rewriteValueRISCV64_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueRISCV64_OpGeq32U_0(v)
+ return rewriteValueRISCV64_OpGeq32U(v)
case OpGeq64:
- return rewriteValueRISCV64_OpGeq64_0(v)
+ return rewriteValueRISCV64_OpGeq64(v)
case OpGeq64F:
- return rewriteValueRISCV64_OpGeq64F_0(v)
+ return rewriteValueRISCV64_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueRISCV64_OpGeq64U_0(v)
+ return rewriteValueRISCV64_OpGeq64U(v)
case OpGeq8:
- return rewriteValueRISCV64_OpGeq8_0(v)
+ return rewriteValueRISCV64_OpGeq8(v)
case OpGeq8U:
- return rewriteValueRISCV64_OpGeq8U_0(v)
+ return rewriteValueRISCV64_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueRISCV64_OpGetCallerPC_0(v)
+ return rewriteValueRISCV64_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueRISCV64_OpGetCallerSP_0(v)
+ return rewriteValueRISCV64_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueRISCV64_OpGetClosurePtr_0(v)
+ return rewriteValueRISCV64_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueRISCV64_OpGreater16_0(v)
+ return rewriteValueRISCV64_OpGreater16(v)
case OpGreater16U:
- return rewriteValueRISCV64_OpGreater16U_0(v)
+ return rewriteValueRISCV64_OpGreater16U(v)
case OpGreater32:
- return rewriteValueRISCV64_OpGreater32_0(v)
+ return rewriteValueRISCV64_OpGreater32(v)
case OpGreater32F:
- return rewriteValueRISCV64_OpGreater32F_0(v)
+ return rewriteValueRISCV64_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueRISCV64_OpGreater32U_0(v)
+ return rewriteValueRISCV64_OpGreater32U(v)
case OpGreater64:
- return rewriteValueRISCV64_OpGreater64_0(v)
+ return rewriteValueRISCV64_OpGreater64(v)
case OpGreater64F:
- return rewriteValueRISCV64_OpGreater64F_0(v)
+ return rewriteValueRISCV64_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueRISCV64_OpGreater64U_0(v)
+ return rewriteValueRISCV64_OpGreater64U(v)
case OpGreater8:
- return rewriteValueRISCV64_OpGreater8_0(v)
+ return rewriteValueRISCV64_OpGreater8(v)
case OpGreater8U:
- return rewriteValueRISCV64_OpGreater8U_0(v)
+ return rewriteValueRISCV64_OpGreater8U(v)
case OpHmul32:
- return rewriteValueRISCV64_OpHmul32_0(v)
+ return rewriteValueRISCV64_OpHmul32(v)
case OpHmul32u:
- return rewriteValueRISCV64_OpHmul32u_0(v)
+ return rewriteValueRISCV64_OpHmul32u(v)
case OpHmul64:
- return rewriteValueRISCV64_OpHmul64_0(v)
+ return rewriteValueRISCV64_OpHmul64(v)
case OpHmul64u:
- return rewriteValueRISCV64_OpHmul64u_0(v)
+ return rewriteValueRISCV64_OpHmul64u(v)
case OpInterCall:
- return rewriteValueRISCV64_OpInterCall_0(v)
+ return rewriteValueRISCV64_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueRISCV64_OpIsInBounds_0(v)
+ return rewriteValueRISCV64_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueRISCV64_OpIsNonNil_0(v)
+ return rewriteValueRISCV64_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueRISCV64_OpIsSliceInBounds_0(v)
+ return rewriteValueRISCV64_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueRISCV64_OpLeq16_0(v)
+ return rewriteValueRISCV64_OpLeq16(v)
case OpLeq16U:
- return rewriteValueRISCV64_OpLeq16U_0(v)
+ return rewriteValueRISCV64_OpLeq16U(v)
case OpLeq32:
- return rewriteValueRISCV64_OpLeq32_0(v)
+ return rewriteValueRISCV64_OpLeq32(v)
case OpLeq32F:
- return rewriteValueRISCV64_OpLeq32F_0(v)
+ return rewriteValueRISCV64_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueRISCV64_OpLeq32U_0(v)
+ return rewriteValueRISCV64_OpLeq32U(v)
case OpLeq64:
- return rewriteValueRISCV64_OpLeq64_0(v)
+ return rewriteValueRISCV64_OpLeq64(v)
case OpLeq64F:
- return rewriteValueRISCV64_OpLeq64F_0(v)
+ return rewriteValueRISCV64_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueRISCV64_OpLeq64U_0(v)
+ return rewriteValueRISCV64_OpLeq64U(v)
case OpLeq8:
- return rewriteValueRISCV64_OpLeq8_0(v)
+ return rewriteValueRISCV64_OpLeq8(v)
case OpLeq8U:
- return rewriteValueRISCV64_OpLeq8U_0(v)
+ return rewriteValueRISCV64_OpLeq8U(v)
case OpLess16:
- return rewriteValueRISCV64_OpLess16_0(v)
+ return rewriteValueRISCV64_OpLess16(v)
case OpLess16U:
- return rewriteValueRISCV64_OpLess16U_0(v)
+ return rewriteValueRISCV64_OpLess16U(v)
case OpLess32:
- return rewriteValueRISCV64_OpLess32_0(v)
+ return rewriteValueRISCV64_OpLess32(v)
case OpLess32F:
- return rewriteValueRISCV64_OpLess32F_0(v)
+ return rewriteValueRISCV64_OpLess32F(v)
case OpLess32U:
- return rewriteValueRISCV64_OpLess32U_0(v)
+ return rewriteValueRISCV64_OpLess32U(v)
case OpLess64:
- return rewriteValueRISCV64_OpLess64_0(v)
+ return rewriteValueRISCV64_OpLess64(v)
case OpLess64F:
- return rewriteValueRISCV64_OpLess64F_0(v)
+ return rewriteValueRISCV64_OpLess64F(v)
case OpLess64U:
- return rewriteValueRISCV64_OpLess64U_0(v)
+ return rewriteValueRISCV64_OpLess64U(v)
case OpLess8:
- return rewriteValueRISCV64_OpLess8_0(v)
+ return rewriteValueRISCV64_OpLess8(v)
case OpLess8U:
- return rewriteValueRISCV64_OpLess8U_0(v)
+ return rewriteValueRISCV64_OpLess8U(v)
case OpLoad:
- return rewriteValueRISCV64_OpLoad_0(v)
+ return rewriteValueRISCV64_OpLoad(v)
case OpLocalAddr:
- return rewriteValueRISCV64_OpLocalAddr_0(v)
+ return rewriteValueRISCV64_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueRISCV64_OpLsh16x16_0(v)
+ return rewriteValueRISCV64_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueRISCV64_OpLsh16x32_0(v)
+ return rewriteValueRISCV64_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueRISCV64_OpLsh16x64_0(v)
+ return rewriteValueRISCV64_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueRISCV64_OpLsh16x8_0(v)
+ return rewriteValueRISCV64_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueRISCV64_OpLsh32x16_0(v)
+ return rewriteValueRISCV64_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueRISCV64_OpLsh32x32_0(v)
+ return rewriteValueRISCV64_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueRISCV64_OpLsh32x64_0(v)
+ return rewriteValueRISCV64_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueRISCV64_OpLsh32x8_0(v)
+ return rewriteValueRISCV64_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueRISCV64_OpLsh64x16_0(v)
+ return rewriteValueRISCV64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueRISCV64_OpLsh64x32_0(v)
+ return rewriteValueRISCV64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueRISCV64_OpLsh64x64_0(v)
+ return rewriteValueRISCV64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueRISCV64_OpLsh64x8_0(v)
+ return rewriteValueRISCV64_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueRISCV64_OpLsh8x16_0(v)
+ return rewriteValueRISCV64_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueRISCV64_OpLsh8x32_0(v)
+ return rewriteValueRISCV64_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueRISCV64_OpLsh8x64_0(v)
+ return rewriteValueRISCV64_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueRISCV64_OpLsh8x8_0(v)
+ return rewriteValueRISCV64_OpLsh8x8(v)
case OpMod16:
- return rewriteValueRISCV64_OpMod16_0(v)
+ return rewriteValueRISCV64_OpMod16(v)
case OpMod16u:
- return rewriteValueRISCV64_OpMod16u_0(v)
+ return rewriteValueRISCV64_OpMod16u(v)
case OpMod32:
- return rewriteValueRISCV64_OpMod32_0(v)
+ return rewriteValueRISCV64_OpMod32(v)
case OpMod32u:
- return rewriteValueRISCV64_OpMod32u_0(v)
+ return rewriteValueRISCV64_OpMod32u(v)
case OpMod64:
- return rewriteValueRISCV64_OpMod64_0(v)
+ return rewriteValueRISCV64_OpMod64(v)
case OpMod64u:
- return rewriteValueRISCV64_OpMod64u_0(v)
+ return rewriteValueRISCV64_OpMod64u(v)
case OpMod8:
- return rewriteValueRISCV64_OpMod8_0(v)
+ return rewriteValueRISCV64_OpMod8(v)
case OpMod8u:
- return rewriteValueRISCV64_OpMod8u_0(v)
+ return rewriteValueRISCV64_OpMod8u(v)
case OpMove:
- return rewriteValueRISCV64_OpMove_0(v)
+ return rewriteValueRISCV64_OpMove(v)
case OpMul16:
- return rewriteValueRISCV64_OpMul16_0(v)
+ return rewriteValueRISCV64_OpMul16(v)
case OpMul32:
- return rewriteValueRISCV64_OpMul32_0(v)
+ return rewriteValueRISCV64_OpMul32(v)
case OpMul32F:
- return rewriteValueRISCV64_OpMul32F_0(v)
+ return rewriteValueRISCV64_OpMul32F(v)
case OpMul64:
- return rewriteValueRISCV64_OpMul64_0(v)
+ return rewriteValueRISCV64_OpMul64(v)
case OpMul64F:
- return rewriteValueRISCV64_OpMul64F_0(v)
+ return rewriteValueRISCV64_OpMul64F(v)
case OpMul8:
- return rewriteValueRISCV64_OpMul8_0(v)
+ return rewriteValueRISCV64_OpMul8(v)
case OpNeg16:
- return rewriteValueRISCV64_OpNeg16_0(v)
+ return rewriteValueRISCV64_OpNeg16(v)
case OpNeg32:
- return rewriteValueRISCV64_OpNeg32_0(v)
+ return rewriteValueRISCV64_OpNeg32(v)
case OpNeg32F:
- return rewriteValueRISCV64_OpNeg32F_0(v)
+ return rewriteValueRISCV64_OpNeg32F(v)
case OpNeg64:
- return rewriteValueRISCV64_OpNeg64_0(v)
+ return rewriteValueRISCV64_OpNeg64(v)
case OpNeg64F:
- return rewriteValueRISCV64_OpNeg64F_0(v)
+ return rewriteValueRISCV64_OpNeg64F(v)
case OpNeg8:
- return rewriteValueRISCV64_OpNeg8_0(v)
+ return rewriteValueRISCV64_OpNeg8(v)
case OpNeq16:
- return rewriteValueRISCV64_OpNeq16_0(v)
+ return rewriteValueRISCV64_OpNeq16(v)
case OpNeq32:
- return rewriteValueRISCV64_OpNeq32_0(v)
+ return rewriteValueRISCV64_OpNeq32(v)
case OpNeq32F:
- return rewriteValueRISCV64_OpNeq32F_0(v)
+ return rewriteValueRISCV64_OpNeq32F(v)
case OpNeq64:
- return rewriteValueRISCV64_OpNeq64_0(v)
+ return rewriteValueRISCV64_OpNeq64(v)
case OpNeq64F:
- return rewriteValueRISCV64_OpNeq64F_0(v)
+ return rewriteValueRISCV64_OpNeq64F(v)
case OpNeq8:
- return rewriteValueRISCV64_OpNeq8_0(v)
+ return rewriteValueRISCV64_OpNeq8(v)
case OpNeqB:
- return rewriteValueRISCV64_OpNeqB_0(v)
+ return rewriteValueRISCV64_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueRISCV64_OpNeqPtr_0(v)
+ return rewriteValueRISCV64_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueRISCV64_OpNilCheck_0(v)
+ return rewriteValueRISCV64_OpNilCheck(v)
case OpNot:
- return rewriteValueRISCV64_OpNot_0(v)
+ return rewriteValueRISCV64_OpNot(v)
case OpOffPtr:
- return rewriteValueRISCV64_OpOffPtr_0(v)
+ return rewriteValueRISCV64_OpOffPtr(v)
case OpOr16:
- return rewriteValueRISCV64_OpOr16_0(v)
+ return rewriteValueRISCV64_OpOr16(v)
case OpOr32:
- return rewriteValueRISCV64_OpOr32_0(v)
+ return rewriteValueRISCV64_OpOr32(v)
case OpOr64:
- return rewriteValueRISCV64_OpOr64_0(v)
+ return rewriteValueRISCV64_OpOr64(v)
case OpOr8:
- return rewriteValueRISCV64_OpOr8_0(v)
+ return rewriteValueRISCV64_OpOr8(v)
case OpOrB:
- return rewriteValueRISCV64_OpOrB_0(v)
+ return rewriteValueRISCV64_OpOrB(v)
case OpPanicBounds:
- return rewriteValueRISCV64_OpPanicBounds_0(v)
+ return rewriteValueRISCV64_OpPanicBounds(v)
case OpRISCV64ADD:
- return rewriteValueRISCV64_OpRISCV64ADD_0(v)
+ return rewriteValueRISCV64_OpRISCV64ADD(v)
case OpRISCV64ADDI:
- return rewriteValueRISCV64_OpRISCV64ADDI_0(v)
+ return rewriteValueRISCV64_OpRISCV64ADDI(v)
case OpRISCV64MOVBUload:
- return rewriteValueRISCV64_OpRISCV64MOVBUload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVBUload(v)
case OpRISCV64MOVBload:
- return rewriteValueRISCV64_OpRISCV64MOVBload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVBload(v)
case OpRISCV64MOVBstore:
- return rewriteValueRISCV64_OpRISCV64MOVBstore_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVBstore(v)
case OpRISCV64MOVDconst:
- return rewriteValueRISCV64_OpRISCV64MOVDconst_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVDconst(v)
case OpRISCV64MOVDload:
- return rewriteValueRISCV64_OpRISCV64MOVDload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVDload(v)
case OpRISCV64MOVDstore:
- return rewriteValueRISCV64_OpRISCV64MOVDstore_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVDstore(v)
case OpRISCV64MOVHUload:
- return rewriteValueRISCV64_OpRISCV64MOVHUload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVHUload(v)
case OpRISCV64MOVHload:
- return rewriteValueRISCV64_OpRISCV64MOVHload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVHload(v)
case OpRISCV64MOVHstore:
- return rewriteValueRISCV64_OpRISCV64MOVHstore_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVHstore(v)
case OpRISCV64MOVWUload:
- return rewriteValueRISCV64_OpRISCV64MOVWUload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVWUload(v)
case OpRISCV64MOVWload:
- return rewriteValueRISCV64_OpRISCV64MOVWload_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVWload(v)
case OpRISCV64MOVWstore:
- return rewriteValueRISCV64_OpRISCV64MOVWstore_0(v)
+ return rewriteValueRISCV64_OpRISCV64MOVWstore(v)
case OpRotateLeft16:
- return rewriteValueRISCV64_OpRotateLeft16_0(v)
+ return rewriteValueRISCV64_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueRISCV64_OpRotateLeft32_0(v)
+ return rewriteValueRISCV64_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueRISCV64_OpRotateLeft64_0(v)
+ return rewriteValueRISCV64_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueRISCV64_OpRotateLeft8_0(v)
+ return rewriteValueRISCV64_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueRISCV64_OpRound32F_0(v)
+ return rewriteValueRISCV64_OpRound32F(v)
case OpRound64F:
- return rewriteValueRISCV64_OpRound64F_0(v)
+ return rewriteValueRISCV64_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValueRISCV64_OpRsh16Ux16_0(v)
+ return rewriteValueRISCV64_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueRISCV64_OpRsh16Ux32_0(v)
+ return rewriteValueRISCV64_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueRISCV64_OpRsh16Ux64_0(v)
+ return rewriteValueRISCV64_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueRISCV64_OpRsh16Ux8_0(v)
+ return rewriteValueRISCV64_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueRISCV64_OpRsh16x16_0(v)
+ return rewriteValueRISCV64_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueRISCV64_OpRsh16x32_0(v)
+ return rewriteValueRISCV64_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueRISCV64_OpRsh16x64_0(v)
+ return rewriteValueRISCV64_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueRISCV64_OpRsh16x8_0(v)
+ return rewriteValueRISCV64_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueRISCV64_OpRsh32Ux16_0(v)
+ return rewriteValueRISCV64_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueRISCV64_OpRsh32Ux32_0(v)
+ return rewriteValueRISCV64_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueRISCV64_OpRsh32Ux64_0(v)
+ return rewriteValueRISCV64_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueRISCV64_OpRsh32Ux8_0(v)
+ return rewriteValueRISCV64_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueRISCV64_OpRsh32x16_0(v)
+ return rewriteValueRISCV64_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueRISCV64_OpRsh32x32_0(v)
+ return rewriteValueRISCV64_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueRISCV64_OpRsh32x64_0(v)
+ return rewriteValueRISCV64_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueRISCV64_OpRsh32x8_0(v)
+ return rewriteValueRISCV64_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueRISCV64_OpRsh64Ux16_0(v)
+ return rewriteValueRISCV64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueRISCV64_OpRsh64Ux32_0(v)
+ return rewriteValueRISCV64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueRISCV64_OpRsh64Ux64_0(v)
+ return rewriteValueRISCV64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueRISCV64_OpRsh64Ux8_0(v)
+ return rewriteValueRISCV64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueRISCV64_OpRsh64x16_0(v)
+ return rewriteValueRISCV64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueRISCV64_OpRsh64x32_0(v)
+ return rewriteValueRISCV64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueRISCV64_OpRsh64x64_0(v)
+ return rewriteValueRISCV64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueRISCV64_OpRsh64x8_0(v)
+ return rewriteValueRISCV64_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueRISCV64_OpRsh8Ux16_0(v)
+ return rewriteValueRISCV64_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueRISCV64_OpRsh8Ux32_0(v)
+ return rewriteValueRISCV64_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueRISCV64_OpRsh8Ux64_0(v)
+ return rewriteValueRISCV64_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueRISCV64_OpRsh8Ux8_0(v)
+ return rewriteValueRISCV64_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueRISCV64_OpRsh8x16_0(v)
+ return rewriteValueRISCV64_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueRISCV64_OpRsh8x32_0(v)
+ return rewriteValueRISCV64_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueRISCV64_OpRsh8x64_0(v)
+ return rewriteValueRISCV64_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueRISCV64_OpRsh8x8_0(v)
+ return rewriteValueRISCV64_OpRsh8x8(v)
case OpSignExt16to32:
- return rewriteValueRISCV64_OpSignExt16to32_0(v)
+ return rewriteValueRISCV64_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValueRISCV64_OpSignExt16to64_0(v)
+ return rewriteValueRISCV64_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValueRISCV64_OpSignExt32to64_0(v)
+ return rewriteValueRISCV64_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValueRISCV64_OpSignExt8to16_0(v)
+ return rewriteValueRISCV64_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueRISCV64_OpSignExt8to32_0(v)
+ return rewriteValueRISCV64_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValueRISCV64_OpSignExt8to64_0(v)
+ return rewriteValueRISCV64_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValueRISCV64_OpSlicemask_0(v)
+ return rewriteValueRISCV64_OpSlicemask(v)
case OpSqrt:
- return rewriteValueRISCV64_OpSqrt_0(v)
+ return rewriteValueRISCV64_OpSqrt(v)
case OpStaticCall:
- return rewriteValueRISCV64_OpStaticCall_0(v)
+ return rewriteValueRISCV64_OpStaticCall(v)
case OpStore:
- return rewriteValueRISCV64_OpStore_0(v)
+ return rewriteValueRISCV64_OpStore(v)
case OpSub16:
- return rewriteValueRISCV64_OpSub16_0(v)
+ return rewriteValueRISCV64_OpSub16(v)
case OpSub32:
- return rewriteValueRISCV64_OpSub32_0(v)
+ return rewriteValueRISCV64_OpSub32(v)
case OpSub32F:
- return rewriteValueRISCV64_OpSub32F_0(v)
+ return rewriteValueRISCV64_OpSub32F(v)
case OpSub64:
- return rewriteValueRISCV64_OpSub64_0(v)
+ return rewriteValueRISCV64_OpSub64(v)
case OpSub64F:
- return rewriteValueRISCV64_OpSub64F_0(v)
+ return rewriteValueRISCV64_OpSub64F(v)
case OpSub8:
- return rewriteValueRISCV64_OpSub8_0(v)
+ return rewriteValueRISCV64_OpSub8(v)
case OpSubPtr:
- return rewriteValueRISCV64_OpSubPtr_0(v)
+ return rewriteValueRISCV64_OpSubPtr(v)
case OpTrunc16to8:
- return rewriteValueRISCV64_OpTrunc16to8_0(v)
+ return rewriteValueRISCV64_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueRISCV64_OpTrunc32to16_0(v)
+ return rewriteValueRISCV64_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueRISCV64_OpTrunc32to8_0(v)
+ return rewriteValueRISCV64_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValueRISCV64_OpTrunc64to16_0(v)
+ return rewriteValueRISCV64_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValueRISCV64_OpTrunc64to32_0(v)
+ return rewriteValueRISCV64_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValueRISCV64_OpTrunc64to8_0(v)
+ return rewriteValueRISCV64_OpTrunc64to8(v)
case OpWB:
- return rewriteValueRISCV64_OpWB_0(v)
+ return rewriteValueRISCV64_OpWB(v)
case OpXor16:
- return rewriteValueRISCV64_OpXor16_0(v)
+ return rewriteValueRISCV64_OpXor16(v)
case OpXor32:
- return rewriteValueRISCV64_OpXor32_0(v)
+ return rewriteValueRISCV64_OpXor32(v)
case OpXor64:
- return rewriteValueRISCV64_OpXor64_0(v)
+ return rewriteValueRISCV64_OpXor64(v)
case OpXor8:
- return rewriteValueRISCV64_OpXor8_0(v)
+ return rewriteValueRISCV64_OpXor8(v)
case OpZero:
- return rewriteValueRISCV64_OpZero_0(v)
+ return rewriteValueRISCV64_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueRISCV64_OpZeroExt16to32_0(v)
+ return rewriteValueRISCV64_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValueRISCV64_OpZeroExt16to64_0(v)
+ return rewriteValueRISCV64_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValueRISCV64_OpZeroExt32to64_0(v)
+ return rewriteValueRISCV64_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValueRISCV64_OpZeroExt8to16_0(v)
+ return rewriteValueRISCV64_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueRISCV64_OpZeroExt8to32_0(v)
+ return rewriteValueRISCV64_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValueRISCV64_OpZeroExt8to64_0(v)
+ return rewriteValueRISCV64_OpZeroExt8to64(v)
}
return false
}
-func rewriteValueRISCV64_OpAdd16_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -525,7 +525,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAdd32_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -539,7 +539,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAdd32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -553,7 +553,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAdd64_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -567,7 +567,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAdd64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -581,7 +581,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAdd8_0(v *Value) bool {
+func rewriteValueRISCV64_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -595,7 +595,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAddPtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -609,7 +609,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAddr_0(v *Value) bool {
+func rewriteValueRISCV64_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVaddr {sym} base)
@@ -622,7 +622,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAnd16_0(v *Value) bool {
+func rewriteValueRISCV64_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -636,7 +636,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAnd32_0(v *Value) bool {
+func rewriteValueRISCV64_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -650,7 +650,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAnd64_0(v *Value) bool {
+func rewriteValueRISCV64_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -664,7 +664,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAnd8_0(v *Value) bool {
+func rewriteValueRISCV64_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -678,7 +678,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAndB_0(v *Value) bool {
+func rewriteValueRISCV64_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -692,7 +692,7 @@
return true
}
}
-func rewriteValueRISCV64_OpAvg64u_0(v *Value) bool {
+func rewriteValueRISCV64_OpAvg64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -723,7 +723,7 @@
return true
}
}
-func rewriteValueRISCV64_OpClosureCall_0(v *Value) bool {
+func rewriteValueRISCV64_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -742,7 +742,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCom16_0(v *Value) bool {
+func rewriteValueRISCV64_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (XORI [int64(-1)] x)
@@ -754,7 +754,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCom32_0(v *Value) bool {
+func rewriteValueRISCV64_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (XORI [int64(-1)] x)
@@ -766,7 +766,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCom64_0(v *Value) bool {
+func rewriteValueRISCV64_OpCom64(v *Value) bool {
v_0 := v.Args[0]
// match: (Com64 x)
// result: (XORI [int64(-1)] x)
@@ -778,7 +778,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCom8_0(v *Value) bool {
+func rewriteValueRISCV64_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (XORI [int64(-1)] x)
@@ -790,7 +790,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst16_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVHconst [val])
for {
@@ -800,7 +800,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst32_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVWconst [val])
for {
@@ -810,7 +810,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst32F(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (Const32F [val])
@@ -824,7 +824,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst64_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [val])
for {
@@ -834,7 +834,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst64F(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (Const64F [val])
@@ -848,7 +848,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConst8_0(v *Value) bool {
+func rewriteValueRISCV64_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVBconst [val])
for {
@@ -858,7 +858,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConstBool_0(v *Value) bool {
+func rewriteValueRISCV64_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVBconst [b])
for {
@@ -868,7 +868,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConstNil_0(v *Value) bool {
+func rewriteValueRISCV64_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -877,7 +877,7 @@
return true
}
}
-func rewriteValueRISCV64_OpConvert_0(v *Value) bool {
+func rewriteValueRISCV64_OpConvert(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Convert x mem)
@@ -891,7 +891,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (FCVTWS x)
@@ -902,7 +902,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 x)
// result: (FCVTLS x)
@@ -913,7 +913,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (FCVTDS x)
@@ -924,7 +924,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (FCVTSW x)
@@ -935,7 +935,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (FCVTDW x)
@@ -946,7 +946,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (FCVTWD x)
@@ -957,7 +957,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (FCVTSD x)
@@ -968,7 +968,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 x)
// result: (FCVTLD x)
@@ -979,7 +979,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt64to32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F x)
// result: (FCVTSL x)
@@ -990,7 +990,7 @@
return true
}
}
-func rewriteValueRISCV64_OpCvt64to64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F x)
// result: (FCVTDL x)
@@ -1001,7 +1001,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv16_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1021,7 +1021,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv16u_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1041,7 +1041,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv32_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32 x y)
@@ -1055,7 +1055,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1069,7 +1069,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv32u_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32u x y)
@@ -1083,7 +1083,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv64_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1097,7 +1097,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1111,7 +1111,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv64u_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64u x y)
@@ -1125,7 +1125,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv8_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1145,7 +1145,7 @@
return true
}
}
-func rewriteValueRISCV64_OpDiv8u_0(v *Value) bool {
+func rewriteValueRISCV64_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1165,7 +1165,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq16_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1185,7 +1185,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq32_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1205,7 +1205,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq32F x y)
@@ -1219,7 +1219,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq64_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1236,7 +1236,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq64F x y)
@@ -1250,7 +1250,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEq8_0(v *Value) bool {
+func rewriteValueRISCV64_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1270,7 +1270,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEqB_0(v *Value) bool {
+func rewriteValueRISCV64_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1289,7 +1289,7 @@
return true
}
}
-func rewriteValueRISCV64_OpEqPtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1306,7 +1306,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq16_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1324,7 +1324,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq16U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1342,7 +1342,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq32_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1360,7 +1360,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq32F x y)
@@ -1374,7 +1374,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq32U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1392,7 +1392,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq64_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1410,7 +1410,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64F x y)
@@ -1424,7 +1424,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq64U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1442,7 +1442,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq8_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1460,7 +1460,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGeq8U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1478,7 +1478,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueRISCV64_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -1486,7 +1486,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueRISCV64_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -1494,7 +1494,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -1502,7 +1502,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater16_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater16 x y)
@@ -1516,7 +1516,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater16U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater16U x y)
@@ -1530,7 +1530,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater32_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32 x y)
@@ -1544,7 +1544,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32F x y)
@@ -1558,7 +1558,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater32U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32U x y)
@@ -1572,7 +1572,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater64_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64 x y)
@@ -1586,7 +1586,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64F x y)
@@ -1600,7 +1600,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater64U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64U x y)
@@ -1614,7 +1614,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater8_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater8 x y)
@@ -1628,7 +1628,7 @@
return true
}
}
-func rewriteValueRISCV64_OpGreater8U_0(v *Value) bool {
+func rewriteValueRISCV64_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater8U x y)
@@ -1642,7 +1642,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul32_0(v *Value) bool {
+func rewriteValueRISCV64_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1665,7 +1665,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul32u_0(v *Value) bool {
+func rewriteValueRISCV64_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1688,7 +1688,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul64_0(v *Value) bool {
+func rewriteValueRISCV64_OpHmul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64 x y)
@@ -1702,7 +1702,7 @@
return true
}
}
-func rewriteValueRISCV64_OpHmul64u_0(v *Value) bool {
+func rewriteValueRISCV64_OpHmul64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64u x y)
@@ -1716,7 +1716,7 @@
return true
}
}
-func rewriteValueRISCV64_OpInterCall_0(v *Value) bool {
+func rewriteValueRISCV64_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -1732,7 +1732,7 @@
return true
}
}
-func rewriteValueRISCV64_OpIsInBounds_0(v *Value) bool {
+func rewriteValueRISCV64_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -1746,7 +1746,7 @@
return true
}
}
-func rewriteValueRISCV64_OpIsNonNil_0(v *Value) bool {
+func rewriteValueRISCV64_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1761,7 +1761,7 @@
return true
}
}
-func rewriteValueRISCV64_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueRISCV64_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsSliceInBounds idx len)
@@ -1775,7 +1775,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1793,7 +1793,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq16U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1811,7 +1811,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1829,7 +1829,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32F x y)
@@ -1843,7 +1843,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq32U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1861,7 +1861,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1879,7 +1879,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64F x y)
@@ -1893,7 +1893,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq64U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1911,7 +1911,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1929,7 +1929,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLeq8U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1947,7 +1947,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1967,7 +1967,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess16U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1987,7 +1987,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2007,7 +2007,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32F x y)
@@ -2021,7 +2021,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess32U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2041,7 +2041,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 x y)
@@ -2055,7 +2055,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64F x y)
@@ -2069,7 +2069,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess64U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U x y)
@@ -2083,7 +2083,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2103,7 +2103,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLess8U_0(v *Value) bool {
+func rewriteValueRISCV64_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2123,7 +2123,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLoad_0(v *Value) bool {
+func rewriteValueRISCV64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2278,7 +2278,7 @@
}
return false
}
-func rewriteValueRISCV64_OpLocalAddr_0(v *Value) bool {
+func rewriteValueRISCV64_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVaddr {sym} base)
@@ -2291,7 +2291,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh16x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2318,7 +2318,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh16x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2345,7 +2345,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh16x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2369,7 +2369,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh16x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2396,7 +2396,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh32x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2423,7 +2423,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh32x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2450,7 +2450,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh32x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2474,7 +2474,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh32x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2501,7 +2501,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh64x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2528,7 +2528,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh64x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2555,7 +2555,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh64x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2579,7 +2579,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh64x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2606,7 +2606,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh8x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2633,7 +2633,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh8x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2660,7 +2660,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh8x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2684,7 +2684,7 @@
return true
}
}
-func rewriteValueRISCV64_OpLsh8x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2711,7 +2711,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod16_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2731,7 +2731,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod16u_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2751,7 +2751,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod32_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32 x y)
@@ -2765,7 +2765,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod32u_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod32u x y)
@@ -2779,7 +2779,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod64_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -2793,7 +2793,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod64u_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64u x y)
@@ -2807,7 +2807,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod8_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2827,7 +2827,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMod8u_0(v *Value) bool {
+func rewriteValueRISCV64_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2847,7 +2847,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMove_0(v *Value) bool {
+func rewriteValueRISCV64_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2958,7 +2958,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul16_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2978,7 +2978,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul32_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -2992,7 +2992,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -3006,7 +3006,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul64_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64 x y)
@@ -3020,7 +3020,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -3034,7 +3034,7 @@
return true
}
}
-func rewriteValueRISCV64_OpMul8_0(v *Value) bool {
+func rewriteValueRISCV64_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3054,7 +3054,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg16_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3069,7 +3069,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg32_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3084,7 +3084,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (FNEGS x)
@@ -3095,7 +3095,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg64_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3110,7 +3110,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (FNEGD x)
@@ -3121,7 +3121,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeg8_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3136,7 +3136,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq16_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3156,7 +3156,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq32_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3176,7 +3176,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq32F x y)
@@ -3190,7 +3190,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq64_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3207,7 +3207,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq64F x y)
@@ -3221,7 +3221,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeq8_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3241,7 +3241,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeqB_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -3255,7 +3255,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNeqPtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3272,7 +3272,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNilCheck_0(v *Value) bool {
+func rewriteValueRISCV64_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -3286,7 +3286,7 @@
return true
}
}
-func rewriteValueRISCV64_OpNot_0(v *Value) bool {
+func rewriteValueRISCV64_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORI [1] x)
@@ -3298,7 +3298,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOffPtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3342,7 +3342,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOr16_0(v *Value) bool {
+func rewriteValueRISCV64_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -3356,7 +3356,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOr32_0(v *Value) bool {
+func rewriteValueRISCV64_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -3370,7 +3370,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOr64_0(v *Value) bool {
+func rewriteValueRISCV64_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -3384,7 +3384,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOr8_0(v *Value) bool {
+func rewriteValueRISCV64_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -3398,7 +3398,7 @@
return true
}
}
-func rewriteValueRISCV64_OpOrB_0(v *Value) bool {
+func rewriteValueRISCV64_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -3412,7 +3412,7 @@
return true
}
}
-func rewriteValueRISCV64_OpPanicBounds_0(v *Value) bool {
+func rewriteValueRISCV64_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3472,7 +3472,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ADD_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64ADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD (MOVDconst [off]) ptr)
@@ -3497,7 +3497,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64ADDI_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64ADDI(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDI [c] (MOVaddr [d] {s} x))
// cond: is32Bit(c+d)
@@ -3533,7 +3533,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBUload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVBUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -3583,7 +3583,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -3633,7 +3633,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVBstore_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3688,7 +3688,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDconst_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVDconst(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (MOVDconst <t> [c])
@@ -3735,7 +3735,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -3785,7 +3785,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVDstore_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3840,7 +3840,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHUload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVHUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -3890,7 +3890,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -3940,7 +3940,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVHstore_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3995,7 +3995,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWUload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVWUload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWUload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -4045,7 +4045,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWload_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off1] {sym1} (MOVaddr [off2] {sym2} base) mem)
@@ -4095,7 +4095,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRISCV64MOVWstore_0(v *Value) bool {
+func rewriteValueRISCV64_OpRISCV64MOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4150,7 +4150,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4181,7 +4181,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4212,7 +4212,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4243,7 +4243,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4274,7 +4274,7 @@
}
return false
}
-func rewriteValueRISCV64_OpRound32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -4286,7 +4286,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRound64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -4298,7 +4298,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4327,7 +4327,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4356,7 +4356,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4383,7 +4383,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4412,7 +4412,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4443,7 +4443,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4474,7 +4474,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4503,7 +4503,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh16x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4534,7 +4534,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4563,7 +4563,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4592,7 +4592,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4619,7 +4619,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4648,7 +4648,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4679,7 +4679,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4710,7 +4710,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4739,7 +4739,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh32x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4770,7 +4770,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4797,7 +4797,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4824,7 +4824,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4848,7 +4848,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4875,7 +4875,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4904,7 +4904,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4933,7 +4933,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4959,7 +4959,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh64x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4988,7 +4988,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5017,7 +5017,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5046,7 +5046,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5073,7 +5073,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5102,7 +5102,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8x16_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5133,7 +5133,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8x32_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5164,7 +5164,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8x64_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5193,7 +5193,7 @@
return true
}
}
-func rewriteValueRISCV64_OpRsh8x8_0(v *Value) bool {
+func rewriteValueRISCV64_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5224,7 +5224,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt16to32 <t> x)
@@ -5241,7 +5241,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt16to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt16to64 <t> x)
@@ -5258,7 +5258,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt32to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt32to64 <t> x)
@@ -5275,7 +5275,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt8to16 <t> x)
@@ -5292,7 +5292,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt8to32 <t> x)
@@ -5309,7 +5309,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSignExt8to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SignExt8to64 <t> x)
@@ -5326,7 +5326,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSlicemask_0(v *Value) bool {
+func rewriteValueRISCV64_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5353,7 +5353,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSqrt_0(v *Value) bool {
+func rewriteValueRISCV64_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (FSQRTD x)
@@ -5364,7 +5364,7 @@
return true
}
}
-func rewriteValueRISCV64_OpStaticCall_0(v *Value) bool {
+func rewriteValueRISCV64_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -5379,7 +5379,7 @@
return true
}
}
-func rewriteValueRISCV64_OpStore_0(v *Value) bool {
+func rewriteValueRISCV64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5487,7 +5487,7 @@
}
return false
}
-func rewriteValueRISCV64_OpSub16_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -5501,7 +5501,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSub32_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -5515,7 +5515,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSub32F_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -5529,7 +5529,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSub64_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -5543,7 +5543,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSub64F_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -5557,7 +5557,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSub8_0(v *Value) bool {
+func rewriteValueRISCV64_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -5571,7 +5571,7 @@
return true
}
}
-func rewriteValueRISCV64_OpSubPtr_0(v *Value) bool {
+func rewriteValueRISCV64_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -5585,7 +5585,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -5597,7 +5597,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -5609,7 +5609,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -5621,7 +5621,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc64to16_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 x)
// result: x
@@ -5633,7 +5633,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc64to32_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 x)
// result: x
@@ -5645,7 +5645,7 @@
return true
}
}
-func rewriteValueRISCV64_OpTrunc64to8_0(v *Value) bool {
+func rewriteValueRISCV64_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 x)
// result: x
@@ -5657,7 +5657,7 @@
return true
}
}
-func rewriteValueRISCV64_OpWB_0(v *Value) bool {
+func rewriteValueRISCV64_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5676,7 +5676,7 @@
return true
}
}
-func rewriteValueRISCV64_OpXor16_0(v *Value) bool {
+func rewriteValueRISCV64_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -5690,7 +5690,7 @@
return true
}
}
-func rewriteValueRISCV64_OpXor32_0(v *Value) bool {
+func rewriteValueRISCV64_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -5704,7 +5704,7 @@
return true
}
}
-func rewriteValueRISCV64_OpXor64_0(v *Value) bool {
+func rewriteValueRISCV64_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -5718,7 +5718,7 @@
return true
}
}
-func rewriteValueRISCV64_OpXor8_0(v *Value) bool {
+func rewriteValueRISCV64_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -5732,7 +5732,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZero_0(v *Value) bool {
+func rewriteValueRISCV64_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5830,7 +5830,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt16to32 <t> x)
@@ -5847,7 +5847,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt16to64 <t> x)
@@ -5864,7 +5864,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt32to64 <t> x)
@@ -5881,7 +5881,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt8to16 <t> x)
@@ -5898,7 +5898,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt8to32 <t> x)
@@ -5915,7 +5915,7 @@
return true
}
}
-func rewriteValueRISCV64_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValueRISCV64_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (ZeroExt8to64 <t> x)
diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go
index d2b9172..f396bab 100644
--- a/src/cmd/compile/internal/ssa/rewriteS390X.go
+++ b/src/cmd/compile/internal/ssa/rewriteS390X.go
@@ -9,809 +9,809 @@
func rewriteValueS390X(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueS390X_OpAdd16_0(v)
+ return rewriteValueS390X_OpAdd16(v)
case OpAdd32:
- return rewriteValueS390X_OpAdd32_0(v)
+ return rewriteValueS390X_OpAdd32(v)
case OpAdd32F:
- return rewriteValueS390X_OpAdd32F_0(v)
+ return rewriteValueS390X_OpAdd32F(v)
case OpAdd64:
- return rewriteValueS390X_OpAdd64_0(v)
+ return rewriteValueS390X_OpAdd64(v)
case OpAdd64F:
- return rewriteValueS390X_OpAdd64F_0(v)
+ return rewriteValueS390X_OpAdd64F(v)
case OpAdd8:
- return rewriteValueS390X_OpAdd8_0(v)
+ return rewriteValueS390X_OpAdd8(v)
case OpAddPtr:
- return rewriteValueS390X_OpAddPtr_0(v)
+ return rewriteValueS390X_OpAddPtr(v)
case OpAddr:
- return rewriteValueS390X_OpAddr_0(v)
+ return rewriteValueS390X_OpAddr(v)
case OpAnd16:
- return rewriteValueS390X_OpAnd16_0(v)
+ return rewriteValueS390X_OpAnd16(v)
case OpAnd32:
- return rewriteValueS390X_OpAnd32_0(v)
+ return rewriteValueS390X_OpAnd32(v)
case OpAnd64:
- return rewriteValueS390X_OpAnd64_0(v)
+ return rewriteValueS390X_OpAnd64(v)
case OpAnd8:
- return rewriteValueS390X_OpAnd8_0(v)
+ return rewriteValueS390X_OpAnd8(v)
case OpAndB:
- return rewriteValueS390X_OpAndB_0(v)
+ return rewriteValueS390X_OpAndB(v)
case OpAtomicAdd32:
- return rewriteValueS390X_OpAtomicAdd32_0(v)
+ return rewriteValueS390X_OpAtomicAdd32(v)
case OpAtomicAdd64:
- return rewriteValueS390X_OpAtomicAdd64_0(v)
+ return rewriteValueS390X_OpAtomicAdd64(v)
case OpAtomicAnd8:
- return rewriteValueS390X_OpAtomicAnd8_0(v)
+ return rewriteValueS390X_OpAtomicAnd8(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap32(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap64(v)
case OpAtomicExchange32:
- return rewriteValueS390X_OpAtomicExchange32_0(v)
+ return rewriteValueS390X_OpAtomicExchange32(v)
case OpAtomicExchange64:
- return rewriteValueS390X_OpAtomicExchange64_0(v)
+ return rewriteValueS390X_OpAtomicExchange64(v)
case OpAtomicLoad32:
- return rewriteValueS390X_OpAtomicLoad32_0(v)
+ return rewriteValueS390X_OpAtomicLoad32(v)
case OpAtomicLoad64:
- return rewriteValueS390X_OpAtomicLoad64_0(v)
+ return rewriteValueS390X_OpAtomicLoad64(v)
case OpAtomicLoad8:
- return rewriteValueS390X_OpAtomicLoad8_0(v)
+ return rewriteValueS390X_OpAtomicLoad8(v)
case OpAtomicLoadAcq32:
- return rewriteValueS390X_OpAtomicLoadAcq32_0(v)
+ return rewriteValueS390X_OpAtomicLoadAcq32(v)
case OpAtomicLoadPtr:
- return rewriteValueS390X_OpAtomicLoadPtr_0(v)
+ return rewriteValueS390X_OpAtomicLoadPtr(v)
case OpAtomicOr8:
- return rewriteValueS390X_OpAtomicOr8_0(v)
+ return rewriteValueS390X_OpAtomicOr8(v)
case OpAtomicStore32:
- return rewriteValueS390X_OpAtomicStore32_0(v)
+ return rewriteValueS390X_OpAtomicStore32(v)
case OpAtomicStore64:
- return rewriteValueS390X_OpAtomicStore64_0(v)
+ return rewriteValueS390X_OpAtomicStore64(v)
case OpAtomicStore8:
- return rewriteValueS390X_OpAtomicStore8_0(v)
+ return rewriteValueS390X_OpAtomicStore8(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
+ return rewriteValueS390X_OpAtomicStorePtrNoWB(v)
case OpAtomicStoreRel32:
- return rewriteValueS390X_OpAtomicStoreRel32_0(v)
+ return rewriteValueS390X_OpAtomicStoreRel32(v)
case OpAvg64u:
- return rewriteValueS390X_OpAvg64u_0(v)
+ return rewriteValueS390X_OpAvg64u(v)
case OpBitLen64:
- return rewriteValueS390X_OpBitLen64_0(v)
+ return rewriteValueS390X_OpBitLen64(v)
case OpBswap32:
- return rewriteValueS390X_OpBswap32_0(v)
+ return rewriteValueS390X_OpBswap32(v)
case OpBswap64:
- return rewriteValueS390X_OpBswap64_0(v)
+ return rewriteValueS390X_OpBswap64(v)
case OpCeil:
- return rewriteValueS390X_OpCeil_0(v)
+ return rewriteValueS390X_OpCeil(v)
case OpClosureCall:
- return rewriteValueS390X_OpClosureCall_0(v)
+ return rewriteValueS390X_OpClosureCall(v)
case OpCom16:
- return rewriteValueS390X_OpCom16_0(v)
+ return rewriteValueS390X_OpCom16(v)
case OpCom32:
- return rewriteValueS390X_OpCom32_0(v)
+ return rewriteValueS390X_OpCom32(v)
case OpCom64:
- return rewriteValueS390X_OpCom64_0(v)
+ return rewriteValueS390X_OpCom64(v)
case OpCom8:
- return rewriteValueS390X_OpCom8_0(v)
+ return rewriteValueS390X_OpCom8(v)
case OpConst16:
- return rewriteValueS390X_OpConst16_0(v)
+ return rewriteValueS390X_OpConst16(v)
case OpConst32:
- return rewriteValueS390X_OpConst32_0(v)
+ return rewriteValueS390X_OpConst32(v)
case OpConst32F:
- return rewriteValueS390X_OpConst32F_0(v)
+ return rewriteValueS390X_OpConst32F(v)
case OpConst64:
- return rewriteValueS390X_OpConst64_0(v)
+ return rewriteValueS390X_OpConst64(v)
case OpConst64F:
- return rewriteValueS390X_OpConst64F_0(v)
+ return rewriteValueS390X_OpConst64F(v)
case OpConst8:
- return rewriteValueS390X_OpConst8_0(v)
+ return rewriteValueS390X_OpConst8(v)
case OpConstBool:
- return rewriteValueS390X_OpConstBool_0(v)
+ return rewriteValueS390X_OpConstBool(v)
case OpConstNil:
- return rewriteValueS390X_OpConstNil_0(v)
+ return rewriteValueS390X_OpConstNil(v)
case OpCtz32:
- return rewriteValueS390X_OpCtz32_0(v)
+ return rewriteValueS390X_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueS390X_OpCtz32NonZero_0(v)
+ return rewriteValueS390X_OpCtz32NonZero(v)
case OpCtz64:
- return rewriteValueS390X_OpCtz64_0(v)
+ return rewriteValueS390X_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValueS390X_OpCtz64NonZero_0(v)
+ return rewriteValueS390X_OpCtz64NonZero(v)
case OpCvt32Fto32:
- return rewriteValueS390X_OpCvt32Fto32_0(v)
+ return rewriteValueS390X_OpCvt32Fto32(v)
case OpCvt32Fto64:
- return rewriteValueS390X_OpCvt32Fto64_0(v)
+ return rewriteValueS390X_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValueS390X_OpCvt32Fto64F_0(v)
+ return rewriteValueS390X_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValueS390X_OpCvt32to32F_0(v)
+ return rewriteValueS390X_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueS390X_OpCvt32to64F_0(v)
+ return rewriteValueS390X_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueS390X_OpCvt64Fto32_0(v)
+ return rewriteValueS390X_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueS390X_OpCvt64Fto32F_0(v)
+ return rewriteValueS390X_OpCvt64Fto32F(v)
case OpCvt64Fto64:
- return rewriteValueS390X_OpCvt64Fto64_0(v)
+ return rewriteValueS390X_OpCvt64Fto64(v)
case OpCvt64to32F:
- return rewriteValueS390X_OpCvt64to32F_0(v)
+ return rewriteValueS390X_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValueS390X_OpCvt64to64F_0(v)
+ return rewriteValueS390X_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValueS390X_OpDiv16_0(v)
+ return rewriteValueS390X_OpDiv16(v)
case OpDiv16u:
- return rewriteValueS390X_OpDiv16u_0(v)
+ return rewriteValueS390X_OpDiv16u(v)
case OpDiv32:
- return rewriteValueS390X_OpDiv32_0(v)
+ return rewriteValueS390X_OpDiv32(v)
case OpDiv32F:
- return rewriteValueS390X_OpDiv32F_0(v)
+ return rewriteValueS390X_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueS390X_OpDiv32u_0(v)
+ return rewriteValueS390X_OpDiv32u(v)
case OpDiv64:
- return rewriteValueS390X_OpDiv64_0(v)
+ return rewriteValueS390X_OpDiv64(v)
case OpDiv64F:
- return rewriteValueS390X_OpDiv64F_0(v)
+ return rewriteValueS390X_OpDiv64F(v)
case OpDiv64u:
- return rewriteValueS390X_OpDiv64u_0(v)
+ return rewriteValueS390X_OpDiv64u(v)
case OpDiv8:
- return rewriteValueS390X_OpDiv8_0(v)
+ return rewriteValueS390X_OpDiv8(v)
case OpDiv8u:
- return rewriteValueS390X_OpDiv8u_0(v)
+ return rewriteValueS390X_OpDiv8u(v)
case OpEq16:
- return rewriteValueS390X_OpEq16_0(v)
+ return rewriteValueS390X_OpEq16(v)
case OpEq32:
- return rewriteValueS390X_OpEq32_0(v)
+ return rewriteValueS390X_OpEq32(v)
case OpEq32F:
- return rewriteValueS390X_OpEq32F_0(v)
+ return rewriteValueS390X_OpEq32F(v)
case OpEq64:
- return rewriteValueS390X_OpEq64_0(v)
+ return rewriteValueS390X_OpEq64(v)
case OpEq64F:
- return rewriteValueS390X_OpEq64F_0(v)
+ return rewriteValueS390X_OpEq64F(v)
case OpEq8:
- return rewriteValueS390X_OpEq8_0(v)
+ return rewriteValueS390X_OpEq8(v)
case OpEqB:
- return rewriteValueS390X_OpEqB_0(v)
+ return rewriteValueS390X_OpEqB(v)
case OpEqPtr:
- return rewriteValueS390X_OpEqPtr_0(v)
+ return rewriteValueS390X_OpEqPtr(v)
case OpFMA:
- return rewriteValueS390X_OpFMA_0(v)
+ return rewriteValueS390X_OpFMA(v)
case OpFloor:
- return rewriteValueS390X_OpFloor_0(v)
+ return rewriteValueS390X_OpFloor(v)
case OpGeq16:
- return rewriteValueS390X_OpGeq16_0(v)
+ return rewriteValueS390X_OpGeq16(v)
case OpGeq16U:
- return rewriteValueS390X_OpGeq16U_0(v)
+ return rewriteValueS390X_OpGeq16U(v)
case OpGeq32:
- return rewriteValueS390X_OpGeq32_0(v)
+ return rewriteValueS390X_OpGeq32(v)
case OpGeq32F:
- return rewriteValueS390X_OpGeq32F_0(v)
+ return rewriteValueS390X_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueS390X_OpGeq32U_0(v)
+ return rewriteValueS390X_OpGeq32U(v)
case OpGeq64:
- return rewriteValueS390X_OpGeq64_0(v)
+ return rewriteValueS390X_OpGeq64(v)
case OpGeq64F:
- return rewriteValueS390X_OpGeq64F_0(v)
+ return rewriteValueS390X_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueS390X_OpGeq64U_0(v)
+ return rewriteValueS390X_OpGeq64U(v)
case OpGeq8:
- return rewriteValueS390X_OpGeq8_0(v)
+ return rewriteValueS390X_OpGeq8(v)
case OpGeq8U:
- return rewriteValueS390X_OpGeq8U_0(v)
+ return rewriteValueS390X_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueS390X_OpGetCallerPC_0(v)
+ return rewriteValueS390X_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueS390X_OpGetCallerSP_0(v)
+ return rewriteValueS390X_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueS390X_OpGetClosurePtr_0(v)
+ return rewriteValueS390X_OpGetClosurePtr(v)
case OpGetG:
- return rewriteValueS390X_OpGetG_0(v)
+ return rewriteValueS390X_OpGetG(v)
case OpGreater16:
- return rewriteValueS390X_OpGreater16_0(v)
+ return rewriteValueS390X_OpGreater16(v)
case OpGreater16U:
- return rewriteValueS390X_OpGreater16U_0(v)
+ return rewriteValueS390X_OpGreater16U(v)
case OpGreater32:
- return rewriteValueS390X_OpGreater32_0(v)
+ return rewriteValueS390X_OpGreater32(v)
case OpGreater32F:
- return rewriteValueS390X_OpGreater32F_0(v)
+ return rewriteValueS390X_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueS390X_OpGreater32U_0(v)
+ return rewriteValueS390X_OpGreater32U(v)
case OpGreater64:
- return rewriteValueS390X_OpGreater64_0(v)
+ return rewriteValueS390X_OpGreater64(v)
case OpGreater64F:
- return rewriteValueS390X_OpGreater64F_0(v)
+ return rewriteValueS390X_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueS390X_OpGreater64U_0(v)
+ return rewriteValueS390X_OpGreater64U(v)
case OpGreater8:
- return rewriteValueS390X_OpGreater8_0(v)
+ return rewriteValueS390X_OpGreater8(v)
case OpGreater8U:
- return rewriteValueS390X_OpGreater8U_0(v)
+ return rewriteValueS390X_OpGreater8U(v)
case OpHmul32:
- return rewriteValueS390X_OpHmul32_0(v)
+ return rewriteValueS390X_OpHmul32(v)
case OpHmul32u:
- return rewriteValueS390X_OpHmul32u_0(v)
+ return rewriteValueS390X_OpHmul32u(v)
case OpHmul64:
- return rewriteValueS390X_OpHmul64_0(v)
+ return rewriteValueS390X_OpHmul64(v)
case OpHmul64u:
- return rewriteValueS390X_OpHmul64u_0(v)
+ return rewriteValueS390X_OpHmul64u(v)
case OpITab:
- return rewriteValueS390X_OpITab_0(v)
+ return rewriteValueS390X_OpITab(v)
case OpInterCall:
- return rewriteValueS390X_OpInterCall_0(v)
+ return rewriteValueS390X_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueS390X_OpIsInBounds_0(v)
+ return rewriteValueS390X_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueS390X_OpIsNonNil_0(v)
+ return rewriteValueS390X_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueS390X_OpIsSliceInBounds_0(v)
+ return rewriteValueS390X_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueS390X_OpLeq16_0(v)
+ return rewriteValueS390X_OpLeq16(v)
case OpLeq16U:
- return rewriteValueS390X_OpLeq16U_0(v)
+ return rewriteValueS390X_OpLeq16U(v)
case OpLeq32:
- return rewriteValueS390X_OpLeq32_0(v)
+ return rewriteValueS390X_OpLeq32(v)
case OpLeq32F:
- return rewriteValueS390X_OpLeq32F_0(v)
+ return rewriteValueS390X_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueS390X_OpLeq32U_0(v)
+ return rewriteValueS390X_OpLeq32U(v)
case OpLeq64:
- return rewriteValueS390X_OpLeq64_0(v)
+ return rewriteValueS390X_OpLeq64(v)
case OpLeq64F:
- return rewriteValueS390X_OpLeq64F_0(v)
+ return rewriteValueS390X_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueS390X_OpLeq64U_0(v)
+ return rewriteValueS390X_OpLeq64U(v)
case OpLeq8:
- return rewriteValueS390X_OpLeq8_0(v)
+ return rewriteValueS390X_OpLeq8(v)
case OpLeq8U:
- return rewriteValueS390X_OpLeq8U_0(v)
+ return rewriteValueS390X_OpLeq8U(v)
case OpLess16:
- return rewriteValueS390X_OpLess16_0(v)
+ return rewriteValueS390X_OpLess16(v)
case OpLess16U:
- return rewriteValueS390X_OpLess16U_0(v)
+ return rewriteValueS390X_OpLess16U(v)
case OpLess32:
- return rewriteValueS390X_OpLess32_0(v)
+ return rewriteValueS390X_OpLess32(v)
case OpLess32F:
- return rewriteValueS390X_OpLess32F_0(v)
+ return rewriteValueS390X_OpLess32F(v)
case OpLess32U:
- return rewriteValueS390X_OpLess32U_0(v)
+ return rewriteValueS390X_OpLess32U(v)
case OpLess64:
- return rewriteValueS390X_OpLess64_0(v)
+ return rewriteValueS390X_OpLess64(v)
case OpLess64F:
- return rewriteValueS390X_OpLess64F_0(v)
+ return rewriteValueS390X_OpLess64F(v)
case OpLess64U:
- return rewriteValueS390X_OpLess64U_0(v)
+ return rewriteValueS390X_OpLess64U(v)
case OpLess8:
- return rewriteValueS390X_OpLess8_0(v)
+ return rewriteValueS390X_OpLess8(v)
case OpLess8U:
- return rewriteValueS390X_OpLess8U_0(v)
+ return rewriteValueS390X_OpLess8U(v)
case OpLoad:
- return rewriteValueS390X_OpLoad_0(v)
+ return rewriteValueS390X_OpLoad(v)
case OpLocalAddr:
- return rewriteValueS390X_OpLocalAddr_0(v)
+ return rewriteValueS390X_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueS390X_OpLsh16x16_0(v)
+ return rewriteValueS390X_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueS390X_OpLsh16x32_0(v)
+ return rewriteValueS390X_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueS390X_OpLsh16x64_0(v)
+ return rewriteValueS390X_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueS390X_OpLsh16x8_0(v)
+ return rewriteValueS390X_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueS390X_OpLsh32x16_0(v)
+ return rewriteValueS390X_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueS390X_OpLsh32x32_0(v)
+ return rewriteValueS390X_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueS390X_OpLsh32x64_0(v)
+ return rewriteValueS390X_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueS390X_OpLsh32x8_0(v)
+ return rewriteValueS390X_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueS390X_OpLsh64x16_0(v)
+ return rewriteValueS390X_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueS390X_OpLsh64x32_0(v)
+ return rewriteValueS390X_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueS390X_OpLsh64x64_0(v)
+ return rewriteValueS390X_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueS390X_OpLsh64x8_0(v)
+ return rewriteValueS390X_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueS390X_OpLsh8x16_0(v)
+ return rewriteValueS390X_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueS390X_OpLsh8x32_0(v)
+ return rewriteValueS390X_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueS390X_OpLsh8x64_0(v)
+ return rewriteValueS390X_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueS390X_OpLsh8x8_0(v)
+ return rewriteValueS390X_OpLsh8x8(v)
case OpMod16:
- return rewriteValueS390X_OpMod16_0(v)
+ return rewriteValueS390X_OpMod16(v)
case OpMod16u:
- return rewriteValueS390X_OpMod16u_0(v)
+ return rewriteValueS390X_OpMod16u(v)
case OpMod32:
- return rewriteValueS390X_OpMod32_0(v)
+ return rewriteValueS390X_OpMod32(v)
case OpMod32u:
- return rewriteValueS390X_OpMod32u_0(v)
+ return rewriteValueS390X_OpMod32u(v)
case OpMod64:
- return rewriteValueS390X_OpMod64_0(v)
+ return rewriteValueS390X_OpMod64(v)
case OpMod64u:
- return rewriteValueS390X_OpMod64u_0(v)
+ return rewriteValueS390X_OpMod64u(v)
case OpMod8:
- return rewriteValueS390X_OpMod8_0(v)
+ return rewriteValueS390X_OpMod8(v)
case OpMod8u:
- return rewriteValueS390X_OpMod8u_0(v)
+ return rewriteValueS390X_OpMod8u(v)
case OpMove:
- return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
+ return rewriteValueS390X_OpMove(v)
case OpMul16:
- return rewriteValueS390X_OpMul16_0(v)
+ return rewriteValueS390X_OpMul16(v)
case OpMul32:
- return rewriteValueS390X_OpMul32_0(v)
+ return rewriteValueS390X_OpMul32(v)
case OpMul32F:
- return rewriteValueS390X_OpMul32F_0(v)
+ return rewriteValueS390X_OpMul32F(v)
case OpMul64:
- return rewriteValueS390X_OpMul64_0(v)
+ return rewriteValueS390X_OpMul64(v)
case OpMul64F:
- return rewriteValueS390X_OpMul64F_0(v)
+ return rewriteValueS390X_OpMul64F(v)
case OpMul64uhilo:
- return rewriteValueS390X_OpMul64uhilo_0(v)
+ return rewriteValueS390X_OpMul64uhilo(v)
case OpMul8:
- return rewriteValueS390X_OpMul8_0(v)
+ return rewriteValueS390X_OpMul8(v)
case OpNeg16:
- return rewriteValueS390X_OpNeg16_0(v)
+ return rewriteValueS390X_OpNeg16(v)
case OpNeg32:
- return rewriteValueS390X_OpNeg32_0(v)
+ return rewriteValueS390X_OpNeg32(v)
case OpNeg32F:
- return rewriteValueS390X_OpNeg32F_0(v)
+ return rewriteValueS390X_OpNeg32F(v)
case OpNeg64:
- return rewriteValueS390X_OpNeg64_0(v)
+ return rewriteValueS390X_OpNeg64(v)
case OpNeg64F:
- return rewriteValueS390X_OpNeg64F_0(v)
+ return rewriteValueS390X_OpNeg64F(v)
case OpNeg8:
- return rewriteValueS390X_OpNeg8_0(v)
+ return rewriteValueS390X_OpNeg8(v)
case OpNeq16:
- return rewriteValueS390X_OpNeq16_0(v)
+ return rewriteValueS390X_OpNeq16(v)
case OpNeq32:
- return rewriteValueS390X_OpNeq32_0(v)
+ return rewriteValueS390X_OpNeq32(v)
case OpNeq32F:
- return rewriteValueS390X_OpNeq32F_0(v)
+ return rewriteValueS390X_OpNeq32F(v)
case OpNeq64:
- return rewriteValueS390X_OpNeq64_0(v)
+ return rewriteValueS390X_OpNeq64(v)
case OpNeq64F:
- return rewriteValueS390X_OpNeq64F_0(v)
+ return rewriteValueS390X_OpNeq64F(v)
case OpNeq8:
- return rewriteValueS390X_OpNeq8_0(v)
+ return rewriteValueS390X_OpNeq8(v)
case OpNeqB:
- return rewriteValueS390X_OpNeqB_0(v)
+ return rewriteValueS390X_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueS390X_OpNeqPtr_0(v)
+ return rewriteValueS390X_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueS390X_OpNilCheck_0(v)
+ return rewriteValueS390X_OpNilCheck(v)
case OpNot:
- return rewriteValueS390X_OpNot_0(v)
+ return rewriteValueS390X_OpNot(v)
case OpOffPtr:
- return rewriteValueS390X_OpOffPtr_0(v)
+ return rewriteValueS390X_OpOffPtr(v)
case OpOr16:
- return rewriteValueS390X_OpOr16_0(v)
+ return rewriteValueS390X_OpOr16(v)
case OpOr32:
- return rewriteValueS390X_OpOr32_0(v)
+ return rewriteValueS390X_OpOr32(v)
case OpOr64:
- return rewriteValueS390X_OpOr64_0(v)
+ return rewriteValueS390X_OpOr64(v)
case OpOr8:
- return rewriteValueS390X_OpOr8_0(v)
+ return rewriteValueS390X_OpOr8(v)
case OpOrB:
- return rewriteValueS390X_OpOrB_0(v)
+ return rewriteValueS390X_OpOrB(v)
case OpPanicBounds:
- return rewriteValueS390X_OpPanicBounds_0(v)
+ return rewriteValueS390X_OpPanicBounds(v)
case OpPopCount16:
- return rewriteValueS390X_OpPopCount16_0(v)
+ return rewriteValueS390X_OpPopCount16(v)
case OpPopCount32:
- return rewriteValueS390X_OpPopCount32_0(v)
+ return rewriteValueS390X_OpPopCount32(v)
case OpPopCount64:
- return rewriteValueS390X_OpPopCount64_0(v)
+ return rewriteValueS390X_OpPopCount64(v)
case OpPopCount8:
- return rewriteValueS390X_OpPopCount8_0(v)
+ return rewriteValueS390X_OpPopCount8(v)
case OpRotateLeft16:
- return rewriteValueS390X_OpRotateLeft16_0(v)
+ return rewriteValueS390X_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueS390X_OpRotateLeft32_0(v)
+ return rewriteValueS390X_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueS390X_OpRotateLeft64_0(v)
+ return rewriteValueS390X_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueS390X_OpRotateLeft8_0(v)
+ return rewriteValueS390X_OpRotateLeft8(v)
case OpRound:
- return rewriteValueS390X_OpRound_0(v)
+ return rewriteValueS390X_OpRound(v)
case OpRound32F:
- return rewriteValueS390X_OpRound32F_0(v)
+ return rewriteValueS390X_OpRound32F(v)
case OpRound64F:
- return rewriteValueS390X_OpRound64F_0(v)
+ return rewriteValueS390X_OpRound64F(v)
case OpRoundToEven:
- return rewriteValueS390X_OpRoundToEven_0(v)
+ return rewriteValueS390X_OpRoundToEven(v)
case OpRsh16Ux16:
- return rewriteValueS390X_OpRsh16Ux16_0(v)
+ return rewriteValueS390X_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueS390X_OpRsh16Ux32_0(v)
+ return rewriteValueS390X_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueS390X_OpRsh16Ux64_0(v)
+ return rewriteValueS390X_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueS390X_OpRsh16Ux8_0(v)
+ return rewriteValueS390X_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueS390X_OpRsh16x16_0(v)
+ return rewriteValueS390X_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueS390X_OpRsh16x32_0(v)
+ return rewriteValueS390X_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueS390X_OpRsh16x64_0(v)
+ return rewriteValueS390X_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueS390X_OpRsh16x8_0(v)
+ return rewriteValueS390X_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueS390X_OpRsh32Ux16_0(v)
+ return rewriteValueS390X_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueS390X_OpRsh32Ux32_0(v)
+ return rewriteValueS390X_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueS390X_OpRsh32Ux64_0(v)
+ return rewriteValueS390X_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueS390X_OpRsh32Ux8_0(v)
+ return rewriteValueS390X_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueS390X_OpRsh32x16_0(v)
+ return rewriteValueS390X_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueS390X_OpRsh32x32_0(v)
+ return rewriteValueS390X_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueS390X_OpRsh32x64_0(v)
+ return rewriteValueS390X_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueS390X_OpRsh32x8_0(v)
+ return rewriteValueS390X_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueS390X_OpRsh64Ux16_0(v)
+ return rewriteValueS390X_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueS390X_OpRsh64Ux32_0(v)
+ return rewriteValueS390X_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueS390X_OpRsh64Ux64_0(v)
+ return rewriteValueS390X_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueS390X_OpRsh64Ux8_0(v)
+ return rewriteValueS390X_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueS390X_OpRsh64x16_0(v)
+ return rewriteValueS390X_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueS390X_OpRsh64x32_0(v)
+ return rewriteValueS390X_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueS390X_OpRsh64x64_0(v)
+ return rewriteValueS390X_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueS390X_OpRsh64x8_0(v)
+ return rewriteValueS390X_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueS390X_OpRsh8Ux16_0(v)
+ return rewriteValueS390X_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueS390X_OpRsh8Ux32_0(v)
+ return rewriteValueS390X_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueS390X_OpRsh8Ux64_0(v)
+ return rewriteValueS390X_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueS390X_OpRsh8Ux8_0(v)
+ return rewriteValueS390X_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueS390X_OpRsh8x16_0(v)
+ return rewriteValueS390X_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueS390X_OpRsh8x32_0(v)
+ return rewriteValueS390X_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueS390X_OpRsh8x64_0(v)
+ return rewriteValueS390X_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueS390X_OpRsh8x8_0(v)
+ return rewriteValueS390X_OpRsh8x8(v)
case OpS390XADD:
- return rewriteValueS390X_OpS390XADD_0(v)
+ return rewriteValueS390X_OpS390XADD(v)
case OpS390XADDC:
- return rewriteValueS390X_OpS390XADDC_0(v)
+ return rewriteValueS390X_OpS390XADDC(v)
case OpS390XADDE:
- return rewriteValueS390X_OpS390XADDE_0(v)
+ return rewriteValueS390X_OpS390XADDE(v)
case OpS390XADDW:
- return rewriteValueS390X_OpS390XADDW_0(v)
+ return rewriteValueS390X_OpS390XADDW(v)
case OpS390XADDWconst:
- return rewriteValueS390X_OpS390XADDWconst_0(v)
+ return rewriteValueS390X_OpS390XADDWconst(v)
case OpS390XADDWload:
- return rewriteValueS390X_OpS390XADDWload_0(v)
+ return rewriteValueS390X_OpS390XADDWload(v)
case OpS390XADDconst:
- return rewriteValueS390X_OpS390XADDconst_0(v)
+ return rewriteValueS390X_OpS390XADDconst(v)
case OpS390XADDload:
- return rewriteValueS390X_OpS390XADDload_0(v)
+ return rewriteValueS390X_OpS390XADDload(v)
case OpS390XAND:
- return rewriteValueS390X_OpS390XAND_0(v)
+ return rewriteValueS390X_OpS390XAND(v)
case OpS390XANDW:
- return rewriteValueS390X_OpS390XANDW_0(v)
+ return rewriteValueS390X_OpS390XANDW(v)
case OpS390XANDWconst:
- return rewriteValueS390X_OpS390XANDWconst_0(v)
+ return rewriteValueS390X_OpS390XANDWconst(v)
case OpS390XANDWload:
- return rewriteValueS390X_OpS390XANDWload_0(v)
+ return rewriteValueS390X_OpS390XANDWload(v)
case OpS390XANDconst:
- return rewriteValueS390X_OpS390XANDconst_0(v)
+ return rewriteValueS390X_OpS390XANDconst(v)
case OpS390XANDload:
- return rewriteValueS390X_OpS390XANDload_0(v)
+ return rewriteValueS390X_OpS390XANDload(v)
case OpS390XCMP:
- return rewriteValueS390X_OpS390XCMP_0(v)
+ return rewriteValueS390X_OpS390XCMP(v)
case OpS390XCMPU:
- return rewriteValueS390X_OpS390XCMPU_0(v)
+ return rewriteValueS390X_OpS390XCMPU(v)
case OpS390XCMPUconst:
- return rewriteValueS390X_OpS390XCMPUconst_0(v) || rewriteValueS390X_OpS390XCMPUconst_10(v)
+ return rewriteValueS390X_OpS390XCMPUconst(v)
case OpS390XCMPW:
- return rewriteValueS390X_OpS390XCMPW_0(v)
+ return rewriteValueS390X_OpS390XCMPW(v)
case OpS390XCMPWU:
- return rewriteValueS390X_OpS390XCMPWU_0(v)
+ return rewriteValueS390X_OpS390XCMPWU(v)
case OpS390XCMPWUconst:
- return rewriteValueS390X_OpS390XCMPWUconst_0(v)
+ return rewriteValueS390X_OpS390XCMPWUconst(v)
case OpS390XCMPWconst:
- return rewriteValueS390X_OpS390XCMPWconst_0(v)
+ return rewriteValueS390X_OpS390XCMPWconst(v)
case OpS390XCMPconst:
- return rewriteValueS390X_OpS390XCMPconst_0(v) || rewriteValueS390X_OpS390XCMPconst_10(v)
+ return rewriteValueS390X_OpS390XCMPconst(v)
case OpS390XCPSDR:
- return rewriteValueS390X_OpS390XCPSDR_0(v)
+ return rewriteValueS390X_OpS390XCPSDR(v)
case OpS390XFADD:
- return rewriteValueS390X_OpS390XFADD_0(v)
+ return rewriteValueS390X_OpS390XFADD(v)
case OpS390XFADDS:
- return rewriteValueS390X_OpS390XFADDS_0(v)
+ return rewriteValueS390X_OpS390XFADDS(v)
case OpS390XFMOVDload:
- return rewriteValueS390X_OpS390XFMOVDload_0(v)
+ return rewriteValueS390X_OpS390XFMOVDload(v)
case OpS390XFMOVDloadidx:
- return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
+ return rewriteValueS390X_OpS390XFMOVDloadidx(v)
case OpS390XFMOVDstore:
- return rewriteValueS390X_OpS390XFMOVDstore_0(v)
+ return rewriteValueS390X_OpS390XFMOVDstore(v)
case OpS390XFMOVDstoreidx:
- return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
+ return rewriteValueS390X_OpS390XFMOVDstoreidx(v)
case OpS390XFMOVSload:
- return rewriteValueS390X_OpS390XFMOVSload_0(v)
+ return rewriteValueS390X_OpS390XFMOVSload(v)
case OpS390XFMOVSloadidx:
- return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
+ return rewriteValueS390X_OpS390XFMOVSloadidx(v)
case OpS390XFMOVSstore:
- return rewriteValueS390X_OpS390XFMOVSstore_0(v)
+ return rewriteValueS390X_OpS390XFMOVSstore(v)
case OpS390XFMOVSstoreidx:
- return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
+ return rewriteValueS390X_OpS390XFMOVSstoreidx(v)
case OpS390XFNEG:
- return rewriteValueS390X_OpS390XFNEG_0(v)
+ return rewriteValueS390X_OpS390XFNEG(v)
case OpS390XFNEGS:
- return rewriteValueS390X_OpS390XFNEGS_0(v)
+ return rewriteValueS390X_OpS390XFNEGS(v)
case OpS390XFSUB:
- return rewriteValueS390X_OpS390XFSUB_0(v)
+ return rewriteValueS390X_OpS390XFSUB(v)
case OpS390XFSUBS:
- return rewriteValueS390X_OpS390XFSUBS_0(v)
+ return rewriteValueS390X_OpS390XFSUBS(v)
case OpS390XLDGR:
- return rewriteValueS390X_OpS390XLDGR_0(v)
+ return rewriteValueS390X_OpS390XLDGR(v)
case OpS390XLEDBR:
- return rewriteValueS390X_OpS390XLEDBR_0(v)
+ return rewriteValueS390X_OpS390XLEDBR(v)
case OpS390XLGDR:
- return rewriteValueS390X_OpS390XLGDR_0(v)
+ return rewriteValueS390X_OpS390XLGDR(v)
case OpS390XLOCGR:
- return rewriteValueS390X_OpS390XLOCGR_0(v)
+ return rewriteValueS390X_OpS390XLOCGR(v)
case OpS390XLoweredRound32F:
- return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
+ return rewriteValueS390X_OpS390XLoweredRound32F(v)
case OpS390XLoweredRound64F:
- return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
+ return rewriteValueS390X_OpS390XLoweredRound64F(v)
case OpS390XMOVBZload:
- return rewriteValueS390X_OpS390XMOVBZload_0(v)
+ return rewriteValueS390X_OpS390XMOVBZload(v)
case OpS390XMOVBZloadidx:
- return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVBZloadidx(v)
case OpS390XMOVBZreg:
- return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
+ return rewriteValueS390X_OpS390XMOVBZreg(v)
case OpS390XMOVBload:
- return rewriteValueS390X_OpS390XMOVBload_0(v)
+ return rewriteValueS390X_OpS390XMOVBload(v)
case OpS390XMOVBloadidx:
- return rewriteValueS390X_OpS390XMOVBloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVBloadidx(v)
case OpS390XMOVBreg:
- return rewriteValueS390X_OpS390XMOVBreg_0(v) || rewriteValueS390X_OpS390XMOVBreg_10(v)
+ return rewriteValueS390X_OpS390XMOVBreg(v)
case OpS390XMOVBstore:
- return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
+ return rewriteValueS390X_OpS390XMOVBstore(v)
case OpS390XMOVBstoreconst:
- return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
+ return rewriteValueS390X_OpS390XMOVBstoreconst(v)
case OpS390XMOVBstoreidx:
- return rewriteValueS390X_OpS390XMOVBstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVBstoreidx(v)
case OpS390XMOVDaddridx:
- return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
+ return rewriteValueS390X_OpS390XMOVDaddridx(v)
case OpS390XMOVDload:
- return rewriteValueS390X_OpS390XMOVDload_0(v)
+ return rewriteValueS390X_OpS390XMOVDload(v)
case OpS390XMOVDloadidx:
- return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVDloadidx(v)
case OpS390XMOVDstore:
- return rewriteValueS390X_OpS390XMOVDstore_0(v)
+ return rewriteValueS390X_OpS390XMOVDstore(v)
case OpS390XMOVDstoreconst:
- return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
+ return rewriteValueS390X_OpS390XMOVDstoreconst(v)
case OpS390XMOVDstoreidx:
- return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVDstoreidx(v)
case OpS390XMOVHBRstore:
- return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
+ return rewriteValueS390X_OpS390XMOVHBRstore(v)
case OpS390XMOVHBRstoreidx:
- return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVHBRstoreidx(v)
case OpS390XMOVHZload:
- return rewriteValueS390X_OpS390XMOVHZload_0(v)
+ return rewriteValueS390X_OpS390XMOVHZload(v)
case OpS390XMOVHZloadidx:
- return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVHZloadidx(v)
case OpS390XMOVHZreg:
- return rewriteValueS390X_OpS390XMOVHZreg_0(v) || rewriteValueS390X_OpS390XMOVHZreg_10(v)
+ return rewriteValueS390X_OpS390XMOVHZreg(v)
case OpS390XMOVHload:
- return rewriteValueS390X_OpS390XMOVHload_0(v)
+ return rewriteValueS390X_OpS390XMOVHload(v)
case OpS390XMOVHloadidx:
- return rewriteValueS390X_OpS390XMOVHloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVHloadidx(v)
case OpS390XMOVHreg:
- return rewriteValueS390X_OpS390XMOVHreg_0(v) || rewriteValueS390X_OpS390XMOVHreg_10(v)
+ return rewriteValueS390X_OpS390XMOVHreg(v)
case OpS390XMOVHstore:
- return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
+ return rewriteValueS390X_OpS390XMOVHstore(v)
case OpS390XMOVHstoreconst:
- return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
+ return rewriteValueS390X_OpS390XMOVHstoreconst(v)
case OpS390XMOVHstoreidx:
- return rewriteValueS390X_OpS390XMOVHstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVHstoreidx(v)
case OpS390XMOVWBRstore:
- return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
+ return rewriteValueS390X_OpS390XMOVWBRstore(v)
case OpS390XMOVWBRstoreidx:
- return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVWBRstoreidx(v)
case OpS390XMOVWZload:
- return rewriteValueS390X_OpS390XMOVWZload_0(v)
+ return rewriteValueS390X_OpS390XMOVWZload(v)
case OpS390XMOVWZloadidx:
- return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVWZloadidx(v)
case OpS390XMOVWZreg:
- return rewriteValueS390X_OpS390XMOVWZreg_0(v) || rewriteValueS390X_OpS390XMOVWZreg_10(v)
+ return rewriteValueS390X_OpS390XMOVWZreg(v)
case OpS390XMOVWload:
- return rewriteValueS390X_OpS390XMOVWload_0(v)
+ return rewriteValueS390X_OpS390XMOVWload(v)
case OpS390XMOVWloadidx:
- return rewriteValueS390X_OpS390XMOVWloadidx_0(v)
+ return rewriteValueS390X_OpS390XMOVWloadidx(v)
case OpS390XMOVWreg:
- return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
+ return rewriteValueS390X_OpS390XMOVWreg(v)
case OpS390XMOVWstore:
- return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
+ return rewriteValueS390X_OpS390XMOVWstore(v)
case OpS390XMOVWstoreconst:
- return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
+ return rewriteValueS390X_OpS390XMOVWstoreconst(v)
case OpS390XMOVWstoreidx:
- return rewriteValueS390X_OpS390XMOVWstoreidx_0(v)
+ return rewriteValueS390X_OpS390XMOVWstoreidx(v)
case OpS390XMULLD:
- return rewriteValueS390X_OpS390XMULLD_0(v)
+ return rewriteValueS390X_OpS390XMULLD(v)
case OpS390XMULLDconst:
- return rewriteValueS390X_OpS390XMULLDconst_0(v)
+ return rewriteValueS390X_OpS390XMULLDconst(v)
case OpS390XMULLDload:
- return rewriteValueS390X_OpS390XMULLDload_0(v)
+ return rewriteValueS390X_OpS390XMULLDload(v)
case OpS390XMULLW:
- return rewriteValueS390X_OpS390XMULLW_0(v)
+ return rewriteValueS390X_OpS390XMULLW(v)
case OpS390XMULLWconst:
- return rewriteValueS390X_OpS390XMULLWconst_0(v)
+ return rewriteValueS390X_OpS390XMULLWconst(v)
case OpS390XMULLWload:
- return rewriteValueS390X_OpS390XMULLWload_0(v)
+ return rewriteValueS390X_OpS390XMULLWload(v)
case OpS390XNEG:
- return rewriteValueS390X_OpS390XNEG_0(v)
+ return rewriteValueS390X_OpS390XNEG(v)
case OpS390XNEGW:
- return rewriteValueS390X_OpS390XNEGW_0(v)
+ return rewriteValueS390X_OpS390XNEGW(v)
case OpS390XNOT:
- return rewriteValueS390X_OpS390XNOT_0(v)
+ return rewriteValueS390X_OpS390XNOT(v)
case OpS390XNOTW:
- return rewriteValueS390X_OpS390XNOTW_0(v)
+ return rewriteValueS390X_OpS390XNOTW(v)
case OpS390XOR:
- return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v)
+ return rewriteValueS390X_OpS390XOR(v)
case OpS390XORW:
- return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v)
+ return rewriteValueS390X_OpS390XORW(v)
case OpS390XORWconst:
- return rewriteValueS390X_OpS390XORWconst_0(v)
+ return rewriteValueS390X_OpS390XORWconst(v)
case OpS390XORWload:
- return rewriteValueS390X_OpS390XORWload_0(v)
+ return rewriteValueS390X_OpS390XORWload(v)
case OpS390XORconst:
- return rewriteValueS390X_OpS390XORconst_0(v)
+ return rewriteValueS390X_OpS390XORconst(v)
case OpS390XORload:
- return rewriteValueS390X_OpS390XORload_0(v)
+ return rewriteValueS390X_OpS390XORload(v)
case OpS390XRLL:
- return rewriteValueS390X_OpS390XRLL_0(v)
+ return rewriteValueS390X_OpS390XRLL(v)
case OpS390XRLLG:
- return rewriteValueS390X_OpS390XRLLG_0(v)
+ return rewriteValueS390X_OpS390XRLLG(v)
case OpS390XSLD:
- return rewriteValueS390X_OpS390XSLD_0(v)
+ return rewriteValueS390X_OpS390XSLD(v)
case OpS390XSLW:
- return rewriteValueS390X_OpS390XSLW_0(v)
+ return rewriteValueS390X_OpS390XSLW(v)
case OpS390XSRAD:
- return rewriteValueS390X_OpS390XSRAD_0(v)
+ return rewriteValueS390X_OpS390XSRAD(v)
case OpS390XSRADconst:
- return rewriteValueS390X_OpS390XSRADconst_0(v)
+ return rewriteValueS390X_OpS390XSRADconst(v)
case OpS390XSRAW:
- return rewriteValueS390X_OpS390XSRAW_0(v)
+ return rewriteValueS390X_OpS390XSRAW(v)
case OpS390XSRAWconst:
- return rewriteValueS390X_OpS390XSRAWconst_0(v)
+ return rewriteValueS390X_OpS390XSRAWconst(v)
case OpS390XSRD:
- return rewriteValueS390X_OpS390XSRD_0(v)
+ return rewriteValueS390X_OpS390XSRD(v)
case OpS390XSRDconst:
- return rewriteValueS390X_OpS390XSRDconst_0(v)
+ return rewriteValueS390X_OpS390XSRDconst(v)
case OpS390XSRW:
- return rewriteValueS390X_OpS390XSRW_0(v)
+ return rewriteValueS390X_OpS390XSRW(v)
case OpS390XSTM2:
- return rewriteValueS390X_OpS390XSTM2_0(v)
+ return rewriteValueS390X_OpS390XSTM2(v)
case OpS390XSTMG2:
- return rewriteValueS390X_OpS390XSTMG2_0(v)
+ return rewriteValueS390X_OpS390XSTMG2(v)
case OpS390XSUB:
- return rewriteValueS390X_OpS390XSUB_0(v)
+ return rewriteValueS390X_OpS390XSUB(v)
case OpS390XSUBE:
- return rewriteValueS390X_OpS390XSUBE_0(v)
+ return rewriteValueS390X_OpS390XSUBE(v)
case OpS390XSUBW:
- return rewriteValueS390X_OpS390XSUBW_0(v)
+ return rewriteValueS390X_OpS390XSUBW(v)
case OpS390XSUBWconst:
- return rewriteValueS390X_OpS390XSUBWconst_0(v)
+ return rewriteValueS390X_OpS390XSUBWconst(v)
case OpS390XSUBWload:
- return rewriteValueS390X_OpS390XSUBWload_0(v)
+ return rewriteValueS390X_OpS390XSUBWload(v)
case OpS390XSUBconst:
- return rewriteValueS390X_OpS390XSUBconst_0(v)
+ return rewriteValueS390X_OpS390XSUBconst(v)
case OpS390XSUBload:
- return rewriteValueS390X_OpS390XSUBload_0(v)
+ return rewriteValueS390X_OpS390XSUBload(v)
case OpS390XSumBytes2:
- return rewriteValueS390X_OpS390XSumBytes2_0(v)
+ return rewriteValueS390X_OpS390XSumBytes2(v)
case OpS390XSumBytes4:
- return rewriteValueS390X_OpS390XSumBytes4_0(v)
+ return rewriteValueS390X_OpS390XSumBytes4(v)
case OpS390XSumBytes8:
- return rewriteValueS390X_OpS390XSumBytes8_0(v)
+ return rewriteValueS390X_OpS390XSumBytes8(v)
case OpS390XXOR:
- return rewriteValueS390X_OpS390XXOR_0(v)
+ return rewriteValueS390X_OpS390XXOR(v)
case OpS390XXORW:
- return rewriteValueS390X_OpS390XXORW_0(v)
+ return rewriteValueS390X_OpS390XXORW(v)
case OpS390XXORWconst:
- return rewriteValueS390X_OpS390XXORWconst_0(v)
+ return rewriteValueS390X_OpS390XXORWconst(v)
case OpS390XXORWload:
- return rewriteValueS390X_OpS390XXORWload_0(v)
+ return rewriteValueS390X_OpS390XXORWload(v)
case OpS390XXORconst:
- return rewriteValueS390X_OpS390XXORconst_0(v)
+ return rewriteValueS390X_OpS390XXORconst(v)
case OpS390XXORload:
- return rewriteValueS390X_OpS390XXORload_0(v)
+ return rewriteValueS390X_OpS390XXORload(v)
case OpSelect0:
- return rewriteValueS390X_OpSelect0_0(v)
+ return rewriteValueS390X_OpSelect0(v)
case OpSelect1:
- return rewriteValueS390X_OpSelect1_0(v)
+ return rewriteValueS390X_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValueS390X_OpSignExt16to32_0(v)
+ return rewriteValueS390X_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValueS390X_OpSignExt16to64_0(v)
+ return rewriteValueS390X_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValueS390X_OpSignExt32to64_0(v)
+ return rewriteValueS390X_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValueS390X_OpSignExt8to16_0(v)
+ return rewriteValueS390X_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueS390X_OpSignExt8to32_0(v)
+ return rewriteValueS390X_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValueS390X_OpSignExt8to64_0(v)
+ return rewriteValueS390X_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValueS390X_OpSlicemask_0(v)
+ return rewriteValueS390X_OpSlicemask(v)
case OpSqrt:
- return rewriteValueS390X_OpSqrt_0(v)
+ return rewriteValueS390X_OpSqrt(v)
case OpStaticCall:
- return rewriteValueS390X_OpStaticCall_0(v)
+ return rewriteValueS390X_OpStaticCall(v)
case OpStore:
- return rewriteValueS390X_OpStore_0(v)
+ return rewriteValueS390X_OpStore(v)
case OpSub16:
- return rewriteValueS390X_OpSub16_0(v)
+ return rewriteValueS390X_OpSub16(v)
case OpSub32:
- return rewriteValueS390X_OpSub32_0(v)
+ return rewriteValueS390X_OpSub32(v)
case OpSub32F:
- return rewriteValueS390X_OpSub32F_0(v)
+ return rewriteValueS390X_OpSub32F(v)
case OpSub64:
- return rewriteValueS390X_OpSub64_0(v)
+ return rewriteValueS390X_OpSub64(v)
case OpSub64F:
- return rewriteValueS390X_OpSub64F_0(v)
+ return rewriteValueS390X_OpSub64F(v)
case OpSub8:
- return rewriteValueS390X_OpSub8_0(v)
+ return rewriteValueS390X_OpSub8(v)
case OpSubPtr:
- return rewriteValueS390X_OpSubPtr_0(v)
+ return rewriteValueS390X_OpSubPtr(v)
case OpTrunc:
- return rewriteValueS390X_OpTrunc_0(v)
+ return rewriteValueS390X_OpTrunc(v)
case OpTrunc16to8:
- return rewriteValueS390X_OpTrunc16to8_0(v)
+ return rewriteValueS390X_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueS390X_OpTrunc32to16_0(v)
+ return rewriteValueS390X_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueS390X_OpTrunc32to8_0(v)
+ return rewriteValueS390X_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValueS390X_OpTrunc64to16_0(v)
+ return rewriteValueS390X_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValueS390X_OpTrunc64to32_0(v)
+ return rewriteValueS390X_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValueS390X_OpTrunc64to8_0(v)
+ return rewriteValueS390X_OpTrunc64to8(v)
case OpWB:
- return rewriteValueS390X_OpWB_0(v)
+ return rewriteValueS390X_OpWB(v)
case OpXor16:
- return rewriteValueS390X_OpXor16_0(v)
+ return rewriteValueS390X_OpXor16(v)
case OpXor32:
- return rewriteValueS390X_OpXor32_0(v)
+ return rewriteValueS390X_OpXor32(v)
case OpXor64:
- return rewriteValueS390X_OpXor64_0(v)
+ return rewriteValueS390X_OpXor64(v)
case OpXor8:
- return rewriteValueS390X_OpXor8_0(v)
+ return rewriteValueS390X_OpXor8(v)
case OpZero:
- return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
+ return rewriteValueS390X_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueS390X_OpZeroExt16to32_0(v)
+ return rewriteValueS390X_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValueS390X_OpZeroExt16to64_0(v)
+ return rewriteValueS390X_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValueS390X_OpZeroExt32to64_0(v)
+ return rewriteValueS390X_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValueS390X_OpZeroExt8to16_0(v)
+ return rewriteValueS390X_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueS390X_OpZeroExt8to32_0(v)
+ return rewriteValueS390X_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValueS390X_OpZeroExt8to64_0(v)
+ return rewriteValueS390X_OpZeroExt8to64(v)
}
return false
}
-func rewriteValueS390X_OpAdd16_0(v *Value) bool {
+func rewriteValueS390X_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -825,7 +825,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd32_0(v *Value) bool {
+func rewriteValueS390X_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -839,7 +839,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
+func rewriteValueS390X_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -853,7 +853,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd64_0(v *Value) bool {
+func rewriteValueS390X_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -867,7 +867,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
+func rewriteValueS390X_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -881,7 +881,7 @@
return true
}
}
-func rewriteValueS390X_OpAdd8_0(v *Value) bool {
+func rewriteValueS390X_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -895,7 +895,7 @@
return true
}
}
-func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
+func rewriteValueS390X_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -909,7 +909,7 @@
return true
}
}
-func rewriteValueS390X_OpAddr_0(v *Value) bool {
+func rewriteValueS390X_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (MOVDaddr {sym} base)
@@ -922,7 +922,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd16_0(v *Value) bool {
+func rewriteValueS390X_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -936,7 +936,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd32_0(v *Value) bool {
+func rewriteValueS390X_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -950,7 +950,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd64_0(v *Value) bool {
+func rewriteValueS390X_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -964,7 +964,7 @@
return true
}
}
-func rewriteValueS390X_OpAnd8_0(v *Value) bool {
+func rewriteValueS390X_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -978,7 +978,7 @@
return true
}
}
-func rewriteValueS390X_OpAndB_0(v *Value) bool {
+func rewriteValueS390X_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -992,7 +992,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1014,7 +1014,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1036,7 +1036,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicAnd8_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicAnd8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1067,7 +1067,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1087,7 +1087,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -1107,7 +1107,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1124,7 +1124,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1141,7 +1141,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad32 ptr mem)
@@ -1155,7 +1155,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad64 ptr mem)
@@ -1169,7 +1169,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoad8_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoad8 ptr mem)
@@ -1183,7 +1183,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoadAcq32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoadAcq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadAcq32 ptr mem)
@@ -1197,7 +1197,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AtomicLoadPtr ptr mem)
@@ -1211,7 +1211,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicOr8_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicOr8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1241,7 +1241,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1261,7 +1261,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore64(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1281,7 +1281,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStore8_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1301,7 +1301,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1321,7 +1321,7 @@
return true
}
}
-func rewriteValueS390X_OpAtomicStoreRel32_0(v *Value) bool {
+func rewriteValueS390X_OpAtomicStoreRel32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1338,7 +1338,7 @@
return true
}
}
-func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
+func rewriteValueS390X_OpAvg64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1360,7 +1360,7 @@
return true
}
}
-func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
+func rewriteValueS390X_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1378,7 +1378,7 @@
return true
}
}
-func rewriteValueS390X_OpBswap32_0(v *Value) bool {
+func rewriteValueS390X_OpBswap32(v *Value) bool {
v_0 := v.Args[0]
// match: (Bswap32 x)
// result: (MOVWBR x)
@@ -1389,7 +1389,7 @@
return true
}
}
-func rewriteValueS390X_OpBswap64_0(v *Value) bool {
+func rewriteValueS390X_OpBswap64(v *Value) bool {
v_0 := v.Args[0]
// match: (Bswap64 x)
// result: (MOVDBR x)
@@ -1400,7 +1400,7 @@
return true
}
}
-func rewriteValueS390X_OpCeil_0(v *Value) bool {
+func rewriteValueS390X_OpCeil(v *Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (FIDBR [6] x)
@@ -1412,7 +1412,7 @@
return true
}
}
-func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
+func rewriteValueS390X_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -1431,7 +1431,7 @@
return true
}
}
-func rewriteValueS390X_OpCom16_0(v *Value) bool {
+func rewriteValueS390X_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 x)
// result: (NOTW x)
@@ -1442,7 +1442,7 @@
return true
}
}
-func rewriteValueS390X_OpCom32_0(v *Value) bool {
+func rewriteValueS390X_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 x)
// result: (NOTW x)
@@ -1453,7 +1453,7 @@
return true
}
}
-func rewriteValueS390X_OpCom64_0(v *Value) bool {
+func rewriteValueS390X_OpCom64(v *Value) bool {
v_0 := v.Args[0]
// match: (Com64 x)
// result: (NOT x)
@@ -1464,7 +1464,7 @@
return true
}
}
-func rewriteValueS390X_OpCom8_0(v *Value) bool {
+func rewriteValueS390X_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 x)
// result: (NOTW x)
@@ -1475,7 +1475,7 @@
return true
}
}
-func rewriteValueS390X_OpConst16_0(v *Value) bool {
+func rewriteValueS390X_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (MOVDconst [val])
for {
@@ -1485,7 +1485,7 @@
return true
}
}
-func rewriteValueS390X_OpConst32_0(v *Value) bool {
+func rewriteValueS390X_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (MOVDconst [val])
for {
@@ -1495,7 +1495,7 @@
return true
}
}
-func rewriteValueS390X_OpConst32F_0(v *Value) bool {
+func rewriteValueS390X_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (FMOVSconst [val])
for {
@@ -1505,7 +1505,7 @@
return true
}
}
-func rewriteValueS390X_OpConst64_0(v *Value) bool {
+func rewriteValueS390X_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (MOVDconst [val])
for {
@@ -1515,7 +1515,7 @@
return true
}
}
-func rewriteValueS390X_OpConst64F_0(v *Value) bool {
+func rewriteValueS390X_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (FMOVDconst [val])
for {
@@ -1525,7 +1525,7 @@
return true
}
}
-func rewriteValueS390X_OpConst8_0(v *Value) bool {
+func rewriteValueS390X_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (MOVDconst [val])
for {
@@ -1535,7 +1535,7 @@
return true
}
}
-func rewriteValueS390X_OpConstBool_0(v *Value) bool {
+func rewriteValueS390X_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (MOVDconst [b])
for {
@@ -1545,7 +1545,7 @@
return true
}
}
-func rewriteValueS390X_OpConstNil_0(v *Value) bool {
+func rewriteValueS390X_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (MOVDconst [0])
for {
@@ -1554,7 +1554,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz32_0(v *Value) bool {
+func rewriteValueS390X_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1583,7 +1583,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueS390X_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (Ctz32 x)
@@ -1594,7 +1594,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz64_0(v *Value) bool {
+func rewriteValueS390X_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1621,7 +1621,7 @@
return true
}
}
-func rewriteValueS390X_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValueS390X_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64NonZero x)
// result: (Ctz64 x)
@@ -1632,7 +1632,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (CFEBRA x)
@@ -1643,7 +1643,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 x)
// result: (CGEBRA x)
@@ -1654,7 +1654,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (LDEBR x)
@@ -1665,7 +1665,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F x)
// result: (CEFBRA x)
@@ -1676,7 +1676,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F x)
// result: (CDFBRA x)
@@ -1687,7 +1687,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (CFDBRA x)
@@ -1698,7 +1698,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (LEDBR x)
@@ -1709,7 +1709,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 x)
// result: (CGDBRA x)
@@ -1720,7 +1720,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F x)
// result: (CEGBRA x)
@@ -1731,7 +1731,7 @@
return true
}
}
-func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
+func rewriteValueS390X_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F x)
// result: (CDGBRA x)
@@ -1742,7 +1742,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16_0(v *Value) bool {
+func rewriteValueS390X_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1762,7 +1762,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
+func rewriteValueS390X_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1782,7 +1782,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32_0(v *Value) bool {
+func rewriteValueS390X_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1800,7 +1800,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
+func rewriteValueS390X_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1814,7 +1814,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
+func rewriteValueS390X_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1832,7 +1832,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64_0(v *Value) bool {
+func rewriteValueS390X_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1846,7 +1846,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
+func rewriteValueS390X_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1860,7 +1860,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
+func rewriteValueS390X_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64u x y)
@@ -1874,7 +1874,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8_0(v *Value) bool {
+func rewriteValueS390X_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1894,7 +1894,7 @@
return true
}
}
-func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
+func rewriteValueS390X_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1914,7 +1914,7 @@
return true
}
}
-func rewriteValueS390X_OpEq16_0(v *Value) bool {
+func rewriteValueS390X_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1943,7 +1943,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32_0(v *Value) bool {
+func rewriteValueS390X_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1968,7 +1968,7 @@
return true
}
}
-func rewriteValueS390X_OpEq32F_0(v *Value) bool {
+func rewriteValueS390X_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1993,7 +1993,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64_0(v *Value) bool {
+func rewriteValueS390X_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2018,7 +2018,7 @@
return true
}
}
-func rewriteValueS390X_OpEq64F_0(v *Value) bool {
+func rewriteValueS390X_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2043,7 +2043,7 @@
return true
}
}
-func rewriteValueS390X_OpEq8_0(v *Value) bool {
+func rewriteValueS390X_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2072,7 +2072,7 @@
return true
}
}
-func rewriteValueS390X_OpEqB_0(v *Value) bool {
+func rewriteValueS390X_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2101,7 +2101,7 @@
return true
}
}
-func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
+func rewriteValueS390X_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2126,7 +2126,7 @@
return true
}
}
-func rewriteValueS390X_OpFMA_0(v *Value) bool {
+func rewriteValueS390X_OpFMA(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2143,7 +2143,7 @@
return true
}
}
-func rewriteValueS390X_OpFloor_0(v *Value) bool {
+func rewriteValueS390X_OpFloor(v *Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (FIDBR [7] x)
@@ -2155,7 +2155,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq16_0(v *Value) bool {
+func rewriteValueS390X_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2184,7 +2184,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
+func rewriteValueS390X_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2213,7 +2213,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32_0(v *Value) bool {
+func rewriteValueS390X_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2238,7 +2238,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
+func rewriteValueS390X_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2263,7 +2263,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
+func rewriteValueS390X_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2288,7 +2288,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64_0(v *Value) bool {
+func rewriteValueS390X_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2313,7 +2313,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
+func rewriteValueS390X_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2338,7 +2338,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
+func rewriteValueS390X_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2363,7 +2363,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq8_0(v *Value) bool {
+func rewriteValueS390X_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2392,7 +2392,7 @@
return true
}
}
-func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
+func rewriteValueS390X_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2421,7 +2421,7 @@
return true
}
}
-func rewriteValueS390X_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueS390X_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -2429,7 +2429,7 @@
return true
}
}
-func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueS390X_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -2437,7 +2437,7 @@
return true
}
}
-func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueS390X_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -2445,7 +2445,7 @@
return true
}
}
-func rewriteValueS390X_OpGetG_0(v *Value) bool {
+func rewriteValueS390X_OpGetG(v *Value) bool {
v_0 := v.Args[0]
// match: (GetG mem)
// result: (LoweredGetG mem)
@@ -2456,7 +2456,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater16_0(v *Value) bool {
+func rewriteValueS390X_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2485,7 +2485,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
+func rewriteValueS390X_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2514,7 +2514,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32_0(v *Value) bool {
+func rewriteValueS390X_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2539,7 +2539,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
+func rewriteValueS390X_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2564,7 +2564,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
+func rewriteValueS390X_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2589,7 +2589,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64_0(v *Value) bool {
+func rewriteValueS390X_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2614,7 +2614,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
+func rewriteValueS390X_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2639,7 +2639,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
+func rewriteValueS390X_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2664,7 +2664,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater8_0(v *Value) bool {
+func rewriteValueS390X_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2693,7 +2693,7 @@
return true
}
}
-func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
+func rewriteValueS390X_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2722,7 +2722,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32_0(v *Value) bool {
+func rewriteValueS390X_OpHmul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2745,7 +2745,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
+func rewriteValueS390X_OpHmul32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2768,7 +2768,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul64_0(v *Value) bool {
+func rewriteValueS390X_OpHmul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64 x y)
@@ -2782,7 +2782,7 @@
return true
}
}
-func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
+func rewriteValueS390X_OpHmul64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Hmul64u x y)
@@ -2796,7 +2796,7 @@
return true
}
}
-func rewriteValueS390X_OpITab_0(v *Value) bool {
+func rewriteValueS390X_OpITab(v *Value) bool {
v_0 := v.Args[0]
// match: (ITab (Load ptr mem))
// result: (MOVDload ptr mem)
@@ -2813,7 +2813,7 @@
}
return false
}
-func rewriteValueS390X_OpInterCall_0(v *Value) bool {
+func rewriteValueS390X_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -2829,7 +2829,7 @@
return true
}
}
-func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
+func rewriteValueS390X_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2854,7 +2854,7 @@
return true
}
}
-func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
+func rewriteValueS390X_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2877,7 +2877,7 @@
return true
}
}
-func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2902,7 +2902,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16_0(v *Value) bool {
+func rewriteValueS390X_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2931,7 +2931,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
+func rewriteValueS390X_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2960,7 +2960,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32_0(v *Value) bool {
+func rewriteValueS390X_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2985,7 +2985,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
+func rewriteValueS390X_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3010,7 +3010,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
+func rewriteValueS390X_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3035,7 +3035,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64_0(v *Value) bool {
+func rewriteValueS390X_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3060,7 +3060,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
+func rewriteValueS390X_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3085,7 +3085,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
+func rewriteValueS390X_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3110,7 +3110,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8_0(v *Value) bool {
+func rewriteValueS390X_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3139,7 +3139,7 @@
return true
}
}
-func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
+func rewriteValueS390X_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3168,7 +3168,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16_0(v *Value) bool {
+func rewriteValueS390X_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3197,7 +3197,7 @@
return true
}
}
-func rewriteValueS390X_OpLess16U_0(v *Value) bool {
+func rewriteValueS390X_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3226,7 +3226,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32_0(v *Value) bool {
+func rewriteValueS390X_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3251,7 +3251,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32F_0(v *Value) bool {
+func rewriteValueS390X_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3276,7 +3276,7 @@
return true
}
}
-func rewriteValueS390X_OpLess32U_0(v *Value) bool {
+func rewriteValueS390X_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3301,7 +3301,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64_0(v *Value) bool {
+func rewriteValueS390X_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3326,7 +3326,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64F_0(v *Value) bool {
+func rewriteValueS390X_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3351,7 +3351,7 @@
return true
}
}
-func rewriteValueS390X_OpLess64U_0(v *Value) bool {
+func rewriteValueS390X_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3376,7 +3376,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8_0(v *Value) bool {
+func rewriteValueS390X_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3405,7 +3405,7 @@
return true
}
}
-func rewriteValueS390X_OpLess8U_0(v *Value) bool {
+func rewriteValueS390X_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3434,7 +3434,7 @@
return true
}
}
-func rewriteValueS390X_OpLoad_0(v *Value) bool {
+func rewriteValueS390X_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -3574,7 +3574,7 @@
}
return false
}
-func rewriteValueS390X_OpLocalAddr_0(v *Value) bool {
+func rewriteValueS390X_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (MOVDaddr {sym} base)
@@ -3587,7 +3587,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
+func rewriteValueS390X_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3631,7 +3631,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
+func rewriteValueS390X_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3673,7 +3673,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
+func rewriteValueS390X_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3715,7 +3715,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
+func rewriteValueS390X_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3759,7 +3759,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
+func rewriteValueS390X_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3803,7 +3803,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
+func rewriteValueS390X_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3845,7 +3845,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
+func rewriteValueS390X_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3887,7 +3887,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
+func rewriteValueS390X_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3931,7 +3931,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
+func rewriteValueS390X_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3975,7 +3975,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
+func rewriteValueS390X_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4017,7 +4017,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
+func rewriteValueS390X_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4059,7 +4059,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
+func rewriteValueS390X_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4103,7 +4103,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
+func rewriteValueS390X_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4147,7 +4147,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
+func rewriteValueS390X_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4189,7 +4189,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
+func rewriteValueS390X_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4231,7 +4231,7 @@
return true
}
}
-func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
+func rewriteValueS390X_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4275,7 +4275,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16_0(v *Value) bool {
+func rewriteValueS390X_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4295,7 +4295,7 @@
return true
}
}
-func rewriteValueS390X_OpMod16u_0(v *Value) bool {
+func rewriteValueS390X_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4315,7 +4315,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32_0(v *Value) bool {
+func rewriteValueS390X_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4333,7 +4333,7 @@
return true
}
}
-func rewriteValueS390X_OpMod32u_0(v *Value) bool {
+func rewriteValueS390X_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4351,7 +4351,7 @@
return true
}
}
-func rewriteValueS390X_OpMod64_0(v *Value) bool {
+func rewriteValueS390X_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -4365,7 +4365,7 @@
return true
}
}
-func rewriteValueS390X_OpMod64u_0(v *Value) bool {
+func rewriteValueS390X_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64u x y)
@@ -4379,7 +4379,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8_0(v *Value) bool {
+func rewriteValueS390X_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4399,7 +4399,7 @@
return true
}
}
-func rewriteValueS390X_OpMod8u_0(v *Value) bool {
+func rewriteValueS390X_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4419,7 +4419,7 @@
return true
}
}
-func rewriteValueS390X_OpMove_0(v *Value) bool {
+func rewriteValueS390X_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -4653,14 +4653,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueS390X_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Move [7] dst src mem)
// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
for {
@@ -4825,7 +4817,7 @@
}
return false
}
-func rewriteValueS390X_OpMul16_0(v *Value) bool {
+func rewriteValueS390X_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -4839,7 +4831,7 @@
return true
}
}
-func rewriteValueS390X_OpMul32_0(v *Value) bool {
+func rewriteValueS390X_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -4853,7 +4845,7 @@
return true
}
}
-func rewriteValueS390X_OpMul32F_0(v *Value) bool {
+func rewriteValueS390X_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -4867,7 +4859,7 @@
return true
}
}
-func rewriteValueS390X_OpMul64_0(v *Value) bool {
+func rewriteValueS390X_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64 x y)
@@ -4881,7 +4873,7 @@
return true
}
}
-func rewriteValueS390X_OpMul64F_0(v *Value) bool {
+func rewriteValueS390X_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -4895,7 +4887,7 @@
return true
}
}
-func rewriteValueS390X_OpMul64uhilo_0(v *Value) bool {
+func rewriteValueS390X_OpMul64uhilo(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64uhilo x y)
@@ -4909,7 +4901,7 @@
return true
}
}
-func rewriteValueS390X_OpMul8_0(v *Value) bool {
+func rewriteValueS390X_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -4923,7 +4915,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg16_0(v *Value) bool {
+func rewriteValueS390X_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg16 x)
// result: (NEGW x)
@@ -4934,7 +4926,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg32_0(v *Value) bool {
+func rewriteValueS390X_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32 x)
// result: (NEGW x)
@@ -4945,7 +4937,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
+func rewriteValueS390X_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (FNEGS x)
@@ -4956,7 +4948,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg64_0(v *Value) bool {
+func rewriteValueS390X_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64 x)
// result: (NEG x)
@@ -4967,7 +4959,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
+func rewriteValueS390X_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (FNEG x)
@@ -4978,7 +4970,7 @@
return true
}
}
-func rewriteValueS390X_OpNeg8_0(v *Value) bool {
+func rewriteValueS390X_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg8 x)
// result: (NEGW x)
@@ -4989,7 +4981,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq16_0(v *Value) bool {
+func rewriteValueS390X_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5018,7 +5010,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32_0(v *Value) bool {
+func rewriteValueS390X_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5043,7 +5035,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
+func rewriteValueS390X_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5068,7 +5060,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64_0(v *Value) bool {
+func rewriteValueS390X_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5093,7 +5085,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
+func rewriteValueS390X_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5118,7 +5110,7 @@
return true
}
}
-func rewriteValueS390X_OpNeq8_0(v *Value) bool {
+func rewriteValueS390X_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5147,7 +5139,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqB_0(v *Value) bool {
+func rewriteValueS390X_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5176,7 +5168,7 @@
return true
}
}
-func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
+func rewriteValueS390X_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5201,7 +5193,7 @@
return true
}
}
-func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
+func rewriteValueS390X_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -5215,7 +5207,7 @@
return true
}
}
-func rewriteValueS390X_OpNot_0(v *Value) bool {
+func rewriteValueS390X_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (XORWconst [1] x)
@@ -5227,7 +5219,7 @@
return true
}
}
-func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
+func rewriteValueS390X_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5271,7 +5263,7 @@
return true
}
}
-func rewriteValueS390X_OpOr16_0(v *Value) bool {
+func rewriteValueS390X_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -5285,7 +5277,7 @@
return true
}
}
-func rewriteValueS390X_OpOr32_0(v *Value) bool {
+func rewriteValueS390X_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -5299,7 +5291,7 @@
return true
}
}
-func rewriteValueS390X_OpOr64_0(v *Value) bool {
+func rewriteValueS390X_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -5313,7 +5305,7 @@
return true
}
}
-func rewriteValueS390X_OpOr8_0(v *Value) bool {
+func rewriteValueS390X_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -5327,7 +5319,7 @@
return true
}
}
-func rewriteValueS390X_OpOrB_0(v *Value) bool {
+func rewriteValueS390X_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -5341,7 +5333,7 @@
return true
}
}
-func rewriteValueS390X_OpPanicBounds_0(v *Value) bool {
+func rewriteValueS390X_OpPanicBounds(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5401,7 +5393,7 @@
}
return false
}
-func rewriteValueS390X_OpPopCount16_0(v *Value) bool {
+func rewriteValueS390X_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5418,7 +5410,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount32_0(v *Value) bool {
+func rewriteValueS390X_OpPopCount32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5435,7 +5427,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount64_0(v *Value) bool {
+func rewriteValueS390X_OpPopCount64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5452,7 +5444,7 @@
return true
}
}
-func rewriteValueS390X_OpPopCount8_0(v *Value) bool {
+func rewriteValueS390X_OpPopCount8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5467,7 +5459,7 @@
return true
}
}
-func rewriteValueS390X_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueS390X_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5498,7 +5490,7 @@
}
return false
}
-func rewriteValueS390X_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueS390X_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x y)
@@ -5512,7 +5504,7 @@
return true
}
}
-func rewriteValueS390X_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueS390X_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft64 x y)
@@ -5526,7 +5518,7 @@
return true
}
}
-func rewriteValueS390X_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueS390X_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5557,7 +5549,7 @@
}
return false
}
-func rewriteValueS390X_OpRound_0(v *Value) bool {
+func rewriteValueS390X_OpRound(v *Value) bool {
v_0 := v.Args[0]
// match: (Round x)
// result: (FIDBR [1] x)
@@ -5569,7 +5561,7 @@
return true
}
}
-func rewriteValueS390X_OpRound32F_0(v *Value) bool {
+func rewriteValueS390X_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: (LoweredRound32F x)
@@ -5580,7 +5572,7 @@
return true
}
}
-func rewriteValueS390X_OpRound64F_0(v *Value) bool {
+func rewriteValueS390X_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: (LoweredRound64F x)
@@ -5591,7 +5583,7 @@
return true
}
}
-func rewriteValueS390X_OpRoundToEven_0(v *Value) bool {
+func rewriteValueS390X_OpRoundToEven(v *Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (FIDBR [4] x)
@@ -5603,7 +5595,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5651,7 +5643,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5697,7 +5689,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5743,7 +5735,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5791,7 +5783,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5837,7 +5829,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5881,7 +5873,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5925,7 +5917,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5971,7 +5963,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6015,7 +6007,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6057,7 +6049,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6099,7 +6091,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6143,7 +6135,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6185,7 +6177,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6224,7 +6216,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6263,7 +6255,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6305,7 +6297,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6349,7 +6341,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6391,7 +6383,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6433,7 +6425,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6477,7 +6469,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6519,7 +6511,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6558,7 +6550,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6597,7 +6589,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6639,7 +6631,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6687,7 +6679,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6733,7 +6725,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6779,7 +6771,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6827,7 +6819,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6873,7 +6865,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6917,7 +6909,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6961,7 +6953,7 @@
return true
}
}
-func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
+func rewriteValueS390X_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7007,7 +6999,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADD x (MOVDconst [c]))
@@ -7125,7 +7117,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDC_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDC(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDC x (MOVDconst [c]))
@@ -7150,7 +7142,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDE_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7217,7 +7209,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ADDW x (MOVDconst [c]))
@@ -7336,7 +7328,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDWconst [c] x)
// cond: int32(c)==0
@@ -7380,7 +7372,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7435,7 +7427,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
// cond: ((c+d)&1 == 0) && is32Bit(c+d)
@@ -7543,7 +7535,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XADDload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XADDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -7624,7 +7616,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
+func rewriteValueS390X_OpS390XAND(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7792,7 +7784,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XANDW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (ANDW x (MOVDconst [c]))
@@ -7883,7 +7875,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XANDWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDWconst [c] (ANDWconst [d] x))
// result: (ANDWconst [c & d] x)
@@ -7961,7 +7953,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XANDWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8016,7 +8008,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XANDconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ANDconst [c] (ANDconst [d] x))
// result: (ANDconst [c & d] x)
@@ -8068,7 +8060,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XANDload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XANDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -8149,7 +8141,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMP(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8191,7 +8183,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8233,7 +8225,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: uint64(x)==uint64(y)
@@ -8381,10 +8373,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XCMPUconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (CMPUconst (MOVWreg x:(ANDWconst [m] _)) [c])
// cond: int32(m) >= 0
// result: (CMPWUconst x [c])
@@ -8408,7 +8396,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8494,7 +8482,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -8580,7 +8568,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: uint32(x)==uint32(y)
@@ -8707,7 +8695,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
@@ -8852,7 +8840,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
v_0 := v.Args[0]
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
@@ -9000,10 +8988,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XCMPconst_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (CMPconst (MOVWreg x:(ANDWconst [m] _)) [c])
// cond: int32(m) >= 0 && c >= 0
// result: (CMPWUconst x [c])
@@ -9045,7 +9029,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XCPSDR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XCPSDR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (CPSDR y (FMOVDconst [c]))
@@ -9082,7 +9066,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFADD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADD (FMUL y z) x)
@@ -9105,7 +9089,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFADDS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FADDS (FMULS y z) x)
@@ -9128,7 +9112,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
@@ -9273,7 +9257,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9327,7 +9311,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9440,7 +9424,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9499,7 +9483,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FMOVSload [off] {sym} ptr1 (FMOVSstore [off] {sym} ptr2 x _))
@@ -9624,7 +9608,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9678,7 +9662,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -9791,7 +9775,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -9850,7 +9834,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFNEG_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFNEG(v *Value) bool {
v_0 := v.Args[0]
// match: (FNEG (LPDFR x))
// result: (LNDFR x)
@@ -9876,7 +9860,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFNEGS_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFNEGS(v *Value) bool {
v_0 := v.Args[0]
// match: (FNEGS (LPDFR x))
// result: (LNDFR x)
@@ -9902,7 +9886,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUB (FMUL y z) x)
@@ -9922,7 +9906,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUBS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (FSUBS (FMULS y z) x)
@@ -9942,7 +9926,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLDGR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLDGR(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (LDGR <t> (SRDconst [1] (SLDconst [1] x)))
@@ -10058,7 +10042,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLEDBR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLEDBR(v *Value) bool {
v_0 := v.Args[0]
// match: (LEDBR (LPDFR (LDEBR x)))
// result: (LPDFR x)
@@ -10092,7 +10076,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLGDR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLGDR(v *Value) bool {
v_0 := v.Args[0]
// match: (LGDR (LDGR x))
// result: x
@@ -10108,7 +10092,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLOCGR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLOCGR(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10243,7 +10227,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (LoweredRound32F x:(FMOVSconst))
// result: x
@@ -10259,7 +10243,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (LoweredRound64F x:(FMOVDconst))
// result: x
@@ -10275,7 +10259,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBZload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
@@ -10399,7 +10383,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10459,9 +10443,10 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVBZreg e:(MOVBreg x))
// cond: clobberIfDead(e)
// result: (MOVBZreg x)
@@ -10646,12 +10631,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVBZreg x:(Arg <t>))
// cond: !t.IsSigned() && t.Size() == 1
// result: x
@@ -10724,7 +10703,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBload [off] {sym} ptr1 (MOVBstore [off] {sym} ptr2 x _))
@@ -10848,7 +10827,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -10908,9 +10887,10 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVBreg e:(MOVBreg x))
// cond: clobberIfDead(e)
// result: (MOVBreg x)
@@ -11095,12 +11075,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVBreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVBreg x:(Arg <t>))
// cond: t.IsSigned() && t.Size() == 1
// result: x
@@ -11150,7 +11124,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -11410,12 +11384,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// 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)
@@ -11569,7 +11537,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -11645,7 +11613,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12022,7 +11990,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
@@ -12117,7 +12085,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDload [off] {sym} ptr1 (MOVDstore [off] {sym} ptr2 x _))
@@ -12263,7 +12231,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12323,7 +12291,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12552,7 +12520,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
@@ -12602,7 +12570,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12667,7 +12635,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -12791,7 +12759,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -12952,7 +12920,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHZload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
@@ -13077,7 +13045,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13137,9 +13105,10 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVHZreg e:(MOVBZreg x))
// cond: clobberIfDead(e)
// result: (MOVBZreg x)
@@ -13314,12 +13283,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVHZreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVHZreg <t> x:(MOVHloadidx [o] {s} p i mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVHZloadidx <t> [o] {s} p i mem)
@@ -13393,7 +13356,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVHload [off] {sym} ptr1 (MOVHstore [off] {sym} ptr2 x _))
@@ -13518,7 +13481,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -13578,8 +13541,10 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (MOVHreg e:(MOVBreg x))
// cond: clobberIfDead(e)
// result: (MOVBreg x)
@@ -13745,12 +13710,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVHreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (MOVHreg x:(MOVBZloadidx _ _ _))
// cond: (!x.Type.IsSigned() || x.Type.Size() > 1)
// result: x
@@ -13871,7 +13830,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14132,12 +14091,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// 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)
@@ -14173,7 +14126,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14254,7 +14207,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -14477,7 +14430,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14542,7 +14495,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -14626,7 +14579,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWZload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
@@ -14751,7 +14704,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -14811,8 +14764,9 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
// match: (MOVWZreg e:(MOVBZreg x))
// cond: clobberIfDead(e)
// result: (MOVBZreg x)
@@ -14979,11 +14933,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVWZreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVWZreg <t> x:(MOVWload [o] {s} p mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVWZload <t> [o] {s} p mem)
@@ -15068,7 +15017,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWload(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MOVWload [off] {sym} ptr1 (MOVWstore [off] {sym} ptr2 x _))
@@ -15193,7 +15142,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWloadidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWloadidx(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15253,8 +15202,9 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
// match: (MOVWreg e:(MOVBreg x))
// cond: clobberIfDead(e)
// result: (MOVBreg x)
@@ -15421,11 +15371,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
// match: (MOVWreg x:(MOVBZload _ _))
// cond: (!x.Type.IsSigned() || x.Type.Size() > 1)
// result: x
@@ -15578,7 +15523,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -15839,12 +15784,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// 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)
@@ -15911,7 +15850,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15992,7 +15931,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -16136,7 +16075,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLD x (MOVDconst [c]))
@@ -16190,7 +16129,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLDconst [-1] x)
@@ -16288,7 +16227,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLDload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLDload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16369,7 +16308,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (MULLW x (MOVDconst [c]))
@@ -16448,7 +16387,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (MULLWconst [-1] x)
@@ -16546,7 +16485,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XMULLWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -16601,7 +16540,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
+func rewriteValueS390X_OpS390XNEG(v *Value) bool {
v_0 := v.Args[0]
// match: (NEG (MOVDconst [c]))
// result: (MOVDconst [-c])
@@ -16637,7 +16576,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XNEGW(v *Value) bool {
v_0 := v.Args[0]
// match: (NEGW (MOVDconst [c]))
// result: (MOVDconst [int64(int32(-c))])
@@ -16652,7 +16591,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
+func rewriteValueS390X_OpS390XNOT(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -16673,7 +16612,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XNOTW(v *Value) bool {
v_0 := v.Args[0]
// match: (NOTW x)
// cond: true
@@ -16690,10 +16629,11 @@
}
return false
}
-func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ typ := &b.Func.Config.Types
// match: (OR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (ORconst [c] x)
@@ -16953,13 +16893,6 @@
}
break
}
- return false
-}
-func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (OR x1:(MOVBZload [i1] {s} p mem) sh:(SLDconst [8] x0:(MOVBZload [i0] {s} p 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) (MOVHZload [i0] {s} p mem)
@@ -17520,13 +17453,6 @@
}
break
}
- return false
-}
-func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (OR x0:(MOVBZload [i0] {s} p mem) sh:(SLDconst [8] x1:(MOVBZload [i1] {s} p 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 (MOVHBRload [i0] {s} p mem))
@@ -18153,7 +18079,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XORW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18518,13 +18444,6 @@
}
break
}
- return false
-}
-func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) or:(ORW s1:(SLWconst [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,y) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1,y) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
@@ -18953,7 +18872,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XORWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORWconst [c] x)
// cond: int32(c)==0
@@ -18995,7 +18914,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XORWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19050,7 +18969,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (ORconst [0] x)
// result: x
@@ -19088,7 +19007,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XORload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XORload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -19169,7 +19088,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XRLL_0(v *Value) bool {
+func rewriteValueS390X_OpS390XRLL(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RLL x (MOVDconst [c]))
@@ -19187,7 +19106,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XRLLG_0(v *Value) bool {
+func rewriteValueS390X_OpS390XRLLG(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RLLG x (MOVDconst [c]))
@@ -19205,7 +19124,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSLD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19347,7 +19266,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSLW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19489,7 +19408,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19631,7 +19550,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRADconst [c] (MOVDconst [d]))
// result: (MOVDconst [d>>uint64(c)])
@@ -19647,7 +19566,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19789,7 +19708,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SRAWconst [c] (MOVDconst [d]))
// result: (MOVDconst [int64(int32(d))>>uint64(c)])
@@ -19805,7 +19724,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRD(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19947,7 +19866,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRDconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRDconst(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (SRDconst [1] (SLDconst [1] (LGDR <t> x)))
@@ -19971,7 +19890,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSRW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20113,7 +20032,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSTM2(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -20175,7 +20094,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSTMG2(v *Value) bool {
v_3 := v.Args[3]
v_2 := v.Args[2]
v_1 := v.Args[1]
@@ -20215,7 +20134,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20294,7 +20213,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBE_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBE(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20370,7 +20289,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -20467,7 +20386,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBWconst [c] x)
// cond: int32(c) == 0
@@ -20494,7 +20413,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSUBWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20549,7 +20468,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBconst(v *Value) bool {
v_0 := v.Args[0]
// match: (SUBconst [0] x)
// result: x
@@ -20609,7 +20528,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSUBload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -20690,7 +20609,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XSumBytes2_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSumBytes2(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -20707,7 +20626,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSumBytes4_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSumBytes4(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -20726,7 +20645,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XSumBytes8_0(v *Value) bool {
+func rewriteValueS390X_OpS390XSumBytes8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -20745,7 +20664,7 @@
return true
}
}
-func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXOR(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XOR x (MOVDconst [c]))
@@ -20852,7 +20771,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXORW(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (XORW x (MOVDconst [c]))
@@ -20966,7 +20885,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXORWconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORWconst [c] x)
// cond: int32(c)==0
@@ -20996,7 +20915,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORWload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXORWload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21051,7 +20970,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXORconst(v *Value) bool {
v_0 := v.Args[0]
// match: (XORconst [0] x)
// result: x
@@ -21079,7 +20998,7 @@
}
return false
}
-func rewriteValueS390X_OpS390XXORload_0(v *Value) bool {
+func rewriteValueS390X_OpS390XXORload(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21160,7 +21079,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect0_0(v *Value) bool {
+func rewriteValueS390X_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -21283,7 +21202,7 @@
}
return false
}
-func rewriteValueS390X_OpSelect1_0(v *Value) bool {
+func rewriteValueS390X_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -21466,7 +21385,7 @@
}
return false
}
-func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 x)
// result: (MOVHreg x)
@@ -21477,7 +21396,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 x)
// result: (MOVHreg x)
@@ -21488,7 +21407,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 x)
// result: (MOVWreg x)
@@ -21499,7 +21418,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 x)
// result: (MOVBreg x)
@@ -21510,7 +21429,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 x)
// result: (MOVBreg x)
@@ -21521,7 +21440,7 @@
return true
}
}
-func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 x)
// result: (MOVBreg x)
@@ -21532,7 +21451,7 @@
return true
}
}
-func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
+func rewriteValueS390X_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Slicemask <t> x)
@@ -21548,7 +21467,7 @@
return true
}
}
-func rewriteValueS390X_OpSqrt_0(v *Value) bool {
+func rewriteValueS390X_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (FSQRT x)
@@ -21559,7 +21478,7 @@
return true
}
}
-func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
+func rewriteValueS390X_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (CALLstatic [argwid] {target} mem)
@@ -21574,7 +21493,7 @@
return true
}
}
-func rewriteValueS390X_OpStore_0(v *Value) bool {
+func rewriteValueS390X_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21682,7 +21601,7 @@
}
return false
}
-func rewriteValueS390X_OpSub16_0(v *Value) bool {
+func rewriteValueS390X_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -21696,7 +21615,7 @@
return true
}
}
-func rewriteValueS390X_OpSub32_0(v *Value) bool {
+func rewriteValueS390X_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -21710,7 +21629,7 @@
return true
}
}
-func rewriteValueS390X_OpSub32F_0(v *Value) bool {
+func rewriteValueS390X_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -21724,7 +21643,7 @@
return true
}
}
-func rewriteValueS390X_OpSub64_0(v *Value) bool {
+func rewriteValueS390X_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -21738,7 +21657,7 @@
return true
}
}
-func rewriteValueS390X_OpSub64F_0(v *Value) bool {
+func rewriteValueS390X_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -21752,7 +21671,7 @@
return true
}
}
-func rewriteValueS390X_OpSub8_0(v *Value) bool {
+func rewriteValueS390X_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -21766,7 +21685,7 @@
return true
}
}
-func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
+func rewriteValueS390X_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -21780,7 +21699,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (FIDBR [5] x)
@@ -21792,7 +21711,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -21804,7 +21723,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -21816,7 +21735,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -21828,7 +21747,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 x)
// result: x
@@ -21840,7 +21759,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 x)
// result: x
@@ -21852,7 +21771,7 @@
return true
}
}
-func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 x)
// result: x
@@ -21864,7 +21783,7 @@
return true
}
}
-func rewriteValueS390X_OpWB_0(v *Value) bool {
+func rewriteValueS390X_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -21883,7 +21802,7 @@
return true
}
}
-func rewriteValueS390X_OpXor16_0(v *Value) bool {
+func rewriteValueS390X_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -21897,7 +21816,7 @@
return true
}
}
-func rewriteValueS390X_OpXor32_0(v *Value) bool {
+func rewriteValueS390X_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -21911,7 +21830,7 @@
return true
}
}
-func rewriteValueS390X_OpXor64_0(v *Value) bool {
+func rewriteValueS390X_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -21925,7 +21844,7 @@
return true
}
}
-func rewriteValueS390X_OpXor8_0(v *Value) bool {
+func rewriteValueS390X_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -21939,7 +21858,7 @@
return true
}
}
-func rewriteValueS390X_OpZero_0(v *Value) bool {
+func rewriteValueS390X_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22099,12 +22018,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValueS390X_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (Zero [s] destptr mem)
// cond: s > 1024
// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
@@ -22127,7 +22040,7 @@
}
return false
}
-func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 x)
// result: (MOVHZreg x)
@@ -22138,7 +22051,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 x)
// result: (MOVHZreg x)
@@ -22149,7 +22062,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 x)
// result: (MOVWZreg x)
@@ -22160,7 +22073,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 x)
// result: (MOVBZreg x)
@@ -22171,7 +22084,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 x)
// result: (MOVBZreg x)
@@ -22182,7 +22095,7 @@
return true
}
}
-func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 x)
// result: (MOVBZreg x)
diff --git a/src/cmd/compile/internal/ssa/rewriteWasm.go b/src/cmd/compile/internal/ssa/rewriteWasm.go
index 5993e9b..53d03ad 100644
--- a/src/cmd/compile/internal/ssa/rewriteWasm.go
+++ b/src/cmd/compile/internal/ssa/rewriteWasm.go
@@ -9,575 +9,575 @@
func rewriteValueWasm(v *Value) bool {
switch v.Op {
case OpAbs:
- return rewriteValueWasm_OpAbs_0(v)
+ return rewriteValueWasm_OpAbs(v)
case OpAdd16:
- return rewriteValueWasm_OpAdd16_0(v)
+ return rewriteValueWasm_OpAdd16(v)
case OpAdd32:
- return rewriteValueWasm_OpAdd32_0(v)
+ return rewriteValueWasm_OpAdd32(v)
case OpAdd32F:
- return rewriteValueWasm_OpAdd32F_0(v)
+ return rewriteValueWasm_OpAdd32F(v)
case OpAdd64:
- return rewriteValueWasm_OpAdd64_0(v)
+ return rewriteValueWasm_OpAdd64(v)
case OpAdd64F:
- return rewriteValueWasm_OpAdd64F_0(v)
+ return rewriteValueWasm_OpAdd64F(v)
case OpAdd8:
- return rewriteValueWasm_OpAdd8_0(v)
+ return rewriteValueWasm_OpAdd8(v)
case OpAddPtr:
- return rewriteValueWasm_OpAddPtr_0(v)
+ return rewriteValueWasm_OpAddPtr(v)
case OpAddr:
- return rewriteValueWasm_OpAddr_0(v)
+ return rewriteValueWasm_OpAddr(v)
case OpAnd16:
- return rewriteValueWasm_OpAnd16_0(v)
+ return rewriteValueWasm_OpAnd16(v)
case OpAnd32:
- return rewriteValueWasm_OpAnd32_0(v)
+ return rewriteValueWasm_OpAnd32(v)
case OpAnd64:
- return rewriteValueWasm_OpAnd64_0(v)
+ return rewriteValueWasm_OpAnd64(v)
case OpAnd8:
- return rewriteValueWasm_OpAnd8_0(v)
+ return rewriteValueWasm_OpAnd8(v)
case OpAndB:
- return rewriteValueWasm_OpAndB_0(v)
+ return rewriteValueWasm_OpAndB(v)
case OpBitLen64:
- return rewriteValueWasm_OpBitLen64_0(v)
+ return rewriteValueWasm_OpBitLen64(v)
case OpCeil:
- return rewriteValueWasm_OpCeil_0(v)
+ return rewriteValueWasm_OpCeil(v)
case OpClosureCall:
- return rewriteValueWasm_OpClosureCall_0(v)
+ return rewriteValueWasm_OpClosureCall(v)
case OpCom16:
- return rewriteValueWasm_OpCom16_0(v)
+ return rewriteValueWasm_OpCom16(v)
case OpCom32:
- return rewriteValueWasm_OpCom32_0(v)
+ return rewriteValueWasm_OpCom32(v)
case OpCom64:
- return rewriteValueWasm_OpCom64_0(v)
+ return rewriteValueWasm_OpCom64(v)
case OpCom8:
- return rewriteValueWasm_OpCom8_0(v)
+ return rewriteValueWasm_OpCom8(v)
case OpCondSelect:
- return rewriteValueWasm_OpCondSelect_0(v)
+ return rewriteValueWasm_OpCondSelect(v)
case OpConst16:
- return rewriteValueWasm_OpConst16_0(v)
+ return rewriteValueWasm_OpConst16(v)
case OpConst32:
- return rewriteValueWasm_OpConst32_0(v)
+ return rewriteValueWasm_OpConst32(v)
case OpConst32F:
- return rewriteValueWasm_OpConst32F_0(v)
+ return rewriteValueWasm_OpConst32F(v)
case OpConst64:
- return rewriteValueWasm_OpConst64_0(v)
+ return rewriteValueWasm_OpConst64(v)
case OpConst64F:
- return rewriteValueWasm_OpConst64F_0(v)
+ return rewriteValueWasm_OpConst64F(v)
case OpConst8:
- return rewriteValueWasm_OpConst8_0(v)
+ return rewriteValueWasm_OpConst8(v)
case OpConstBool:
- return rewriteValueWasm_OpConstBool_0(v)
+ return rewriteValueWasm_OpConstBool(v)
case OpConstNil:
- return rewriteValueWasm_OpConstNil_0(v)
+ return rewriteValueWasm_OpConstNil(v)
case OpConvert:
- return rewriteValueWasm_OpConvert_0(v)
+ return rewriteValueWasm_OpConvert(v)
case OpCopysign:
- return rewriteValueWasm_OpCopysign_0(v)
+ return rewriteValueWasm_OpCopysign(v)
case OpCtz16:
- return rewriteValueWasm_OpCtz16_0(v)
+ return rewriteValueWasm_OpCtz16(v)
case OpCtz16NonZero:
- return rewriteValueWasm_OpCtz16NonZero_0(v)
+ return rewriteValueWasm_OpCtz16NonZero(v)
case OpCtz32:
- return rewriteValueWasm_OpCtz32_0(v)
+ return rewriteValueWasm_OpCtz32(v)
case OpCtz32NonZero:
- return rewriteValueWasm_OpCtz32NonZero_0(v)
+ return rewriteValueWasm_OpCtz32NonZero(v)
case OpCtz64:
- return rewriteValueWasm_OpCtz64_0(v)
+ return rewriteValueWasm_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValueWasm_OpCtz64NonZero_0(v)
+ return rewriteValueWasm_OpCtz64NonZero(v)
case OpCtz8:
- return rewriteValueWasm_OpCtz8_0(v)
+ return rewriteValueWasm_OpCtz8(v)
case OpCtz8NonZero:
- return rewriteValueWasm_OpCtz8NonZero_0(v)
+ return rewriteValueWasm_OpCtz8NonZero(v)
case OpCvt32Fto32:
- return rewriteValueWasm_OpCvt32Fto32_0(v)
+ return rewriteValueWasm_OpCvt32Fto32(v)
case OpCvt32Fto32U:
- return rewriteValueWasm_OpCvt32Fto32U_0(v)
+ return rewriteValueWasm_OpCvt32Fto32U(v)
case OpCvt32Fto64:
- return rewriteValueWasm_OpCvt32Fto64_0(v)
+ return rewriteValueWasm_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValueWasm_OpCvt32Fto64F_0(v)
+ return rewriteValueWasm_OpCvt32Fto64F(v)
case OpCvt32Fto64U:
- return rewriteValueWasm_OpCvt32Fto64U_0(v)
+ return rewriteValueWasm_OpCvt32Fto64U(v)
case OpCvt32Uto32F:
- return rewriteValueWasm_OpCvt32Uto32F_0(v)
+ return rewriteValueWasm_OpCvt32Uto32F(v)
case OpCvt32Uto64F:
- return rewriteValueWasm_OpCvt32Uto64F_0(v)
+ return rewriteValueWasm_OpCvt32Uto64F(v)
case OpCvt32to32F:
- return rewriteValueWasm_OpCvt32to32F_0(v)
+ return rewriteValueWasm_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValueWasm_OpCvt32to64F_0(v)
+ return rewriteValueWasm_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValueWasm_OpCvt64Fto32_0(v)
+ return rewriteValueWasm_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValueWasm_OpCvt64Fto32F_0(v)
+ return rewriteValueWasm_OpCvt64Fto32F(v)
case OpCvt64Fto32U:
- return rewriteValueWasm_OpCvt64Fto32U_0(v)
+ return rewriteValueWasm_OpCvt64Fto32U(v)
case OpCvt64Fto64:
- return rewriteValueWasm_OpCvt64Fto64_0(v)
+ return rewriteValueWasm_OpCvt64Fto64(v)
case OpCvt64Fto64U:
- return rewriteValueWasm_OpCvt64Fto64U_0(v)
+ return rewriteValueWasm_OpCvt64Fto64U(v)
case OpCvt64Uto32F:
- return rewriteValueWasm_OpCvt64Uto32F_0(v)
+ return rewriteValueWasm_OpCvt64Uto32F(v)
case OpCvt64Uto64F:
- return rewriteValueWasm_OpCvt64Uto64F_0(v)
+ return rewriteValueWasm_OpCvt64Uto64F(v)
case OpCvt64to32F:
- return rewriteValueWasm_OpCvt64to32F_0(v)
+ return rewriteValueWasm_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValueWasm_OpCvt64to64F_0(v)
+ return rewriteValueWasm_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValueWasm_OpDiv16_0(v)
+ return rewriteValueWasm_OpDiv16(v)
case OpDiv16u:
- return rewriteValueWasm_OpDiv16u_0(v)
+ return rewriteValueWasm_OpDiv16u(v)
case OpDiv32:
- return rewriteValueWasm_OpDiv32_0(v)
+ return rewriteValueWasm_OpDiv32(v)
case OpDiv32F:
- return rewriteValueWasm_OpDiv32F_0(v)
+ return rewriteValueWasm_OpDiv32F(v)
case OpDiv32u:
- return rewriteValueWasm_OpDiv32u_0(v)
+ return rewriteValueWasm_OpDiv32u(v)
case OpDiv64:
- return rewriteValueWasm_OpDiv64_0(v)
+ return rewriteValueWasm_OpDiv64(v)
case OpDiv64F:
- return rewriteValueWasm_OpDiv64F_0(v)
+ return rewriteValueWasm_OpDiv64F(v)
case OpDiv64u:
- return rewriteValueWasm_OpDiv64u_0(v)
+ return rewriteValueWasm_OpDiv64u(v)
case OpDiv8:
- return rewriteValueWasm_OpDiv8_0(v)
+ return rewriteValueWasm_OpDiv8(v)
case OpDiv8u:
- return rewriteValueWasm_OpDiv8u_0(v)
+ return rewriteValueWasm_OpDiv8u(v)
case OpEq16:
- return rewriteValueWasm_OpEq16_0(v)
+ return rewriteValueWasm_OpEq16(v)
case OpEq32:
- return rewriteValueWasm_OpEq32_0(v)
+ return rewriteValueWasm_OpEq32(v)
case OpEq32F:
- return rewriteValueWasm_OpEq32F_0(v)
+ return rewriteValueWasm_OpEq32F(v)
case OpEq64:
- return rewriteValueWasm_OpEq64_0(v)
+ return rewriteValueWasm_OpEq64(v)
case OpEq64F:
- return rewriteValueWasm_OpEq64F_0(v)
+ return rewriteValueWasm_OpEq64F(v)
case OpEq8:
- return rewriteValueWasm_OpEq8_0(v)
+ return rewriteValueWasm_OpEq8(v)
case OpEqB:
- return rewriteValueWasm_OpEqB_0(v)
+ return rewriteValueWasm_OpEqB(v)
case OpEqPtr:
- return rewriteValueWasm_OpEqPtr_0(v)
+ return rewriteValueWasm_OpEqPtr(v)
case OpFloor:
- return rewriteValueWasm_OpFloor_0(v)
+ return rewriteValueWasm_OpFloor(v)
case OpGeq16:
- return rewriteValueWasm_OpGeq16_0(v)
+ return rewriteValueWasm_OpGeq16(v)
case OpGeq16U:
- return rewriteValueWasm_OpGeq16U_0(v)
+ return rewriteValueWasm_OpGeq16U(v)
case OpGeq32:
- return rewriteValueWasm_OpGeq32_0(v)
+ return rewriteValueWasm_OpGeq32(v)
case OpGeq32F:
- return rewriteValueWasm_OpGeq32F_0(v)
+ return rewriteValueWasm_OpGeq32F(v)
case OpGeq32U:
- return rewriteValueWasm_OpGeq32U_0(v)
+ return rewriteValueWasm_OpGeq32U(v)
case OpGeq64:
- return rewriteValueWasm_OpGeq64_0(v)
+ return rewriteValueWasm_OpGeq64(v)
case OpGeq64F:
- return rewriteValueWasm_OpGeq64F_0(v)
+ return rewriteValueWasm_OpGeq64F(v)
case OpGeq64U:
- return rewriteValueWasm_OpGeq64U_0(v)
+ return rewriteValueWasm_OpGeq64U(v)
case OpGeq8:
- return rewriteValueWasm_OpGeq8_0(v)
+ return rewriteValueWasm_OpGeq8(v)
case OpGeq8U:
- return rewriteValueWasm_OpGeq8U_0(v)
+ return rewriteValueWasm_OpGeq8U(v)
case OpGetCallerPC:
- return rewriteValueWasm_OpGetCallerPC_0(v)
+ return rewriteValueWasm_OpGetCallerPC(v)
case OpGetCallerSP:
- return rewriteValueWasm_OpGetCallerSP_0(v)
+ return rewriteValueWasm_OpGetCallerSP(v)
case OpGetClosurePtr:
- return rewriteValueWasm_OpGetClosurePtr_0(v)
+ return rewriteValueWasm_OpGetClosurePtr(v)
case OpGreater16:
- return rewriteValueWasm_OpGreater16_0(v)
+ return rewriteValueWasm_OpGreater16(v)
case OpGreater16U:
- return rewriteValueWasm_OpGreater16U_0(v)
+ return rewriteValueWasm_OpGreater16U(v)
case OpGreater32:
- return rewriteValueWasm_OpGreater32_0(v)
+ return rewriteValueWasm_OpGreater32(v)
case OpGreater32F:
- return rewriteValueWasm_OpGreater32F_0(v)
+ return rewriteValueWasm_OpGreater32F(v)
case OpGreater32U:
- return rewriteValueWasm_OpGreater32U_0(v)
+ return rewriteValueWasm_OpGreater32U(v)
case OpGreater64:
- return rewriteValueWasm_OpGreater64_0(v)
+ return rewriteValueWasm_OpGreater64(v)
case OpGreater64F:
- return rewriteValueWasm_OpGreater64F_0(v)
+ return rewriteValueWasm_OpGreater64F(v)
case OpGreater64U:
- return rewriteValueWasm_OpGreater64U_0(v)
+ return rewriteValueWasm_OpGreater64U(v)
case OpGreater8:
- return rewriteValueWasm_OpGreater8_0(v)
+ return rewriteValueWasm_OpGreater8(v)
case OpGreater8U:
- return rewriteValueWasm_OpGreater8U_0(v)
+ return rewriteValueWasm_OpGreater8U(v)
case OpInterCall:
- return rewriteValueWasm_OpInterCall_0(v)
+ return rewriteValueWasm_OpInterCall(v)
case OpIsInBounds:
- return rewriteValueWasm_OpIsInBounds_0(v)
+ return rewriteValueWasm_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValueWasm_OpIsNonNil_0(v)
+ return rewriteValueWasm_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValueWasm_OpIsSliceInBounds_0(v)
+ return rewriteValueWasm_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValueWasm_OpLeq16_0(v)
+ return rewriteValueWasm_OpLeq16(v)
case OpLeq16U:
- return rewriteValueWasm_OpLeq16U_0(v)
+ return rewriteValueWasm_OpLeq16U(v)
case OpLeq32:
- return rewriteValueWasm_OpLeq32_0(v)
+ return rewriteValueWasm_OpLeq32(v)
case OpLeq32F:
- return rewriteValueWasm_OpLeq32F_0(v)
+ return rewriteValueWasm_OpLeq32F(v)
case OpLeq32U:
- return rewriteValueWasm_OpLeq32U_0(v)
+ return rewriteValueWasm_OpLeq32U(v)
case OpLeq64:
- return rewriteValueWasm_OpLeq64_0(v)
+ return rewriteValueWasm_OpLeq64(v)
case OpLeq64F:
- return rewriteValueWasm_OpLeq64F_0(v)
+ return rewriteValueWasm_OpLeq64F(v)
case OpLeq64U:
- return rewriteValueWasm_OpLeq64U_0(v)
+ return rewriteValueWasm_OpLeq64U(v)
case OpLeq8:
- return rewriteValueWasm_OpLeq8_0(v)
+ return rewriteValueWasm_OpLeq8(v)
case OpLeq8U:
- return rewriteValueWasm_OpLeq8U_0(v)
+ return rewriteValueWasm_OpLeq8U(v)
case OpLess16:
- return rewriteValueWasm_OpLess16_0(v)
+ return rewriteValueWasm_OpLess16(v)
case OpLess16U:
- return rewriteValueWasm_OpLess16U_0(v)
+ return rewriteValueWasm_OpLess16U(v)
case OpLess32:
- return rewriteValueWasm_OpLess32_0(v)
+ return rewriteValueWasm_OpLess32(v)
case OpLess32F:
- return rewriteValueWasm_OpLess32F_0(v)
+ return rewriteValueWasm_OpLess32F(v)
case OpLess32U:
- return rewriteValueWasm_OpLess32U_0(v)
+ return rewriteValueWasm_OpLess32U(v)
case OpLess64:
- return rewriteValueWasm_OpLess64_0(v)
+ return rewriteValueWasm_OpLess64(v)
case OpLess64F:
- return rewriteValueWasm_OpLess64F_0(v)
+ return rewriteValueWasm_OpLess64F(v)
case OpLess64U:
- return rewriteValueWasm_OpLess64U_0(v)
+ return rewriteValueWasm_OpLess64U(v)
case OpLess8:
- return rewriteValueWasm_OpLess8_0(v)
+ return rewriteValueWasm_OpLess8(v)
case OpLess8U:
- return rewriteValueWasm_OpLess8U_0(v)
+ return rewriteValueWasm_OpLess8U(v)
case OpLoad:
- return rewriteValueWasm_OpLoad_0(v)
+ return rewriteValueWasm_OpLoad(v)
case OpLocalAddr:
- return rewriteValueWasm_OpLocalAddr_0(v)
+ return rewriteValueWasm_OpLocalAddr(v)
case OpLsh16x16:
- return rewriteValueWasm_OpLsh16x16_0(v)
+ return rewriteValueWasm_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValueWasm_OpLsh16x32_0(v)
+ return rewriteValueWasm_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValueWasm_OpLsh16x64_0(v)
+ return rewriteValueWasm_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValueWasm_OpLsh16x8_0(v)
+ return rewriteValueWasm_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValueWasm_OpLsh32x16_0(v)
+ return rewriteValueWasm_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValueWasm_OpLsh32x32_0(v)
+ return rewriteValueWasm_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValueWasm_OpLsh32x64_0(v)
+ return rewriteValueWasm_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValueWasm_OpLsh32x8_0(v)
+ return rewriteValueWasm_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValueWasm_OpLsh64x16_0(v)
+ return rewriteValueWasm_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValueWasm_OpLsh64x32_0(v)
+ return rewriteValueWasm_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValueWasm_OpLsh64x64_0(v)
+ return rewriteValueWasm_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValueWasm_OpLsh64x8_0(v)
+ return rewriteValueWasm_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValueWasm_OpLsh8x16_0(v)
+ return rewriteValueWasm_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValueWasm_OpLsh8x32_0(v)
+ return rewriteValueWasm_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValueWasm_OpLsh8x64_0(v)
+ return rewriteValueWasm_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValueWasm_OpLsh8x8_0(v)
+ return rewriteValueWasm_OpLsh8x8(v)
case OpMod16:
- return rewriteValueWasm_OpMod16_0(v)
+ return rewriteValueWasm_OpMod16(v)
case OpMod16u:
- return rewriteValueWasm_OpMod16u_0(v)
+ return rewriteValueWasm_OpMod16u(v)
case OpMod32:
- return rewriteValueWasm_OpMod32_0(v)
+ return rewriteValueWasm_OpMod32(v)
case OpMod32u:
- return rewriteValueWasm_OpMod32u_0(v)
+ return rewriteValueWasm_OpMod32u(v)
case OpMod64:
- return rewriteValueWasm_OpMod64_0(v)
+ return rewriteValueWasm_OpMod64(v)
case OpMod64u:
- return rewriteValueWasm_OpMod64u_0(v)
+ return rewriteValueWasm_OpMod64u(v)
case OpMod8:
- return rewriteValueWasm_OpMod8_0(v)
+ return rewriteValueWasm_OpMod8(v)
case OpMod8u:
- return rewriteValueWasm_OpMod8u_0(v)
+ return rewriteValueWasm_OpMod8u(v)
case OpMove:
- return rewriteValueWasm_OpMove_0(v) || rewriteValueWasm_OpMove_10(v)
+ return rewriteValueWasm_OpMove(v)
case OpMul16:
- return rewriteValueWasm_OpMul16_0(v)
+ return rewriteValueWasm_OpMul16(v)
case OpMul32:
- return rewriteValueWasm_OpMul32_0(v)
+ return rewriteValueWasm_OpMul32(v)
case OpMul32F:
- return rewriteValueWasm_OpMul32F_0(v)
+ return rewriteValueWasm_OpMul32F(v)
case OpMul64:
- return rewriteValueWasm_OpMul64_0(v)
+ return rewriteValueWasm_OpMul64(v)
case OpMul64F:
- return rewriteValueWasm_OpMul64F_0(v)
+ return rewriteValueWasm_OpMul64F(v)
case OpMul8:
- return rewriteValueWasm_OpMul8_0(v)
+ return rewriteValueWasm_OpMul8(v)
case OpNeg16:
- return rewriteValueWasm_OpNeg16_0(v)
+ return rewriteValueWasm_OpNeg16(v)
case OpNeg32:
- return rewriteValueWasm_OpNeg32_0(v)
+ return rewriteValueWasm_OpNeg32(v)
case OpNeg32F:
- return rewriteValueWasm_OpNeg32F_0(v)
+ return rewriteValueWasm_OpNeg32F(v)
case OpNeg64:
- return rewriteValueWasm_OpNeg64_0(v)
+ return rewriteValueWasm_OpNeg64(v)
case OpNeg64F:
- return rewriteValueWasm_OpNeg64F_0(v)
+ return rewriteValueWasm_OpNeg64F(v)
case OpNeg8:
- return rewriteValueWasm_OpNeg8_0(v)
+ return rewriteValueWasm_OpNeg8(v)
case OpNeq16:
- return rewriteValueWasm_OpNeq16_0(v)
+ return rewriteValueWasm_OpNeq16(v)
case OpNeq32:
- return rewriteValueWasm_OpNeq32_0(v)
+ return rewriteValueWasm_OpNeq32(v)
case OpNeq32F:
- return rewriteValueWasm_OpNeq32F_0(v)
+ return rewriteValueWasm_OpNeq32F(v)
case OpNeq64:
- return rewriteValueWasm_OpNeq64_0(v)
+ return rewriteValueWasm_OpNeq64(v)
case OpNeq64F:
- return rewriteValueWasm_OpNeq64F_0(v)
+ return rewriteValueWasm_OpNeq64F(v)
case OpNeq8:
- return rewriteValueWasm_OpNeq8_0(v)
+ return rewriteValueWasm_OpNeq8(v)
case OpNeqB:
- return rewriteValueWasm_OpNeqB_0(v)
+ return rewriteValueWasm_OpNeqB(v)
case OpNeqPtr:
- return rewriteValueWasm_OpNeqPtr_0(v)
+ return rewriteValueWasm_OpNeqPtr(v)
case OpNilCheck:
- return rewriteValueWasm_OpNilCheck_0(v)
+ return rewriteValueWasm_OpNilCheck(v)
case OpNot:
- return rewriteValueWasm_OpNot_0(v)
+ return rewriteValueWasm_OpNot(v)
case OpOffPtr:
- return rewriteValueWasm_OpOffPtr_0(v)
+ return rewriteValueWasm_OpOffPtr(v)
case OpOr16:
- return rewriteValueWasm_OpOr16_0(v)
+ return rewriteValueWasm_OpOr16(v)
case OpOr32:
- return rewriteValueWasm_OpOr32_0(v)
+ return rewriteValueWasm_OpOr32(v)
case OpOr64:
- return rewriteValueWasm_OpOr64_0(v)
+ return rewriteValueWasm_OpOr64(v)
case OpOr8:
- return rewriteValueWasm_OpOr8_0(v)
+ return rewriteValueWasm_OpOr8(v)
case OpOrB:
- return rewriteValueWasm_OpOrB_0(v)
+ return rewriteValueWasm_OpOrB(v)
case OpPopCount16:
- return rewriteValueWasm_OpPopCount16_0(v)
+ return rewriteValueWasm_OpPopCount16(v)
case OpPopCount32:
- return rewriteValueWasm_OpPopCount32_0(v)
+ return rewriteValueWasm_OpPopCount32(v)
case OpPopCount64:
- return rewriteValueWasm_OpPopCount64_0(v)
+ return rewriteValueWasm_OpPopCount64(v)
case OpPopCount8:
- return rewriteValueWasm_OpPopCount8_0(v)
+ return rewriteValueWasm_OpPopCount8(v)
case OpRotateLeft16:
- return rewriteValueWasm_OpRotateLeft16_0(v)
+ return rewriteValueWasm_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValueWasm_OpRotateLeft32_0(v)
+ return rewriteValueWasm_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValueWasm_OpRotateLeft64_0(v)
+ return rewriteValueWasm_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValueWasm_OpRotateLeft8_0(v)
+ return rewriteValueWasm_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValueWasm_OpRound32F_0(v)
+ return rewriteValueWasm_OpRound32F(v)
case OpRound64F:
- return rewriteValueWasm_OpRound64F_0(v)
+ return rewriteValueWasm_OpRound64F(v)
case OpRoundToEven:
- return rewriteValueWasm_OpRoundToEven_0(v)
+ return rewriteValueWasm_OpRoundToEven(v)
case OpRsh16Ux16:
- return rewriteValueWasm_OpRsh16Ux16_0(v)
+ return rewriteValueWasm_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValueWasm_OpRsh16Ux32_0(v)
+ return rewriteValueWasm_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValueWasm_OpRsh16Ux64_0(v)
+ return rewriteValueWasm_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValueWasm_OpRsh16Ux8_0(v)
+ return rewriteValueWasm_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValueWasm_OpRsh16x16_0(v)
+ return rewriteValueWasm_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValueWasm_OpRsh16x32_0(v)
+ return rewriteValueWasm_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValueWasm_OpRsh16x64_0(v)
+ return rewriteValueWasm_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValueWasm_OpRsh16x8_0(v)
+ return rewriteValueWasm_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValueWasm_OpRsh32Ux16_0(v)
+ return rewriteValueWasm_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValueWasm_OpRsh32Ux32_0(v)
+ return rewriteValueWasm_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValueWasm_OpRsh32Ux64_0(v)
+ return rewriteValueWasm_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValueWasm_OpRsh32Ux8_0(v)
+ return rewriteValueWasm_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValueWasm_OpRsh32x16_0(v)
+ return rewriteValueWasm_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValueWasm_OpRsh32x32_0(v)
+ return rewriteValueWasm_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValueWasm_OpRsh32x64_0(v)
+ return rewriteValueWasm_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValueWasm_OpRsh32x8_0(v)
+ return rewriteValueWasm_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValueWasm_OpRsh64Ux16_0(v)
+ return rewriteValueWasm_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValueWasm_OpRsh64Ux32_0(v)
+ return rewriteValueWasm_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValueWasm_OpRsh64Ux64_0(v)
+ return rewriteValueWasm_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValueWasm_OpRsh64Ux8_0(v)
+ return rewriteValueWasm_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValueWasm_OpRsh64x16_0(v)
+ return rewriteValueWasm_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValueWasm_OpRsh64x32_0(v)
+ return rewriteValueWasm_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValueWasm_OpRsh64x64_0(v)
+ return rewriteValueWasm_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValueWasm_OpRsh64x8_0(v)
+ return rewriteValueWasm_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValueWasm_OpRsh8Ux16_0(v)
+ return rewriteValueWasm_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValueWasm_OpRsh8Ux32_0(v)
+ return rewriteValueWasm_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValueWasm_OpRsh8Ux64_0(v)
+ return rewriteValueWasm_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValueWasm_OpRsh8Ux8_0(v)
+ return rewriteValueWasm_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValueWasm_OpRsh8x16_0(v)
+ return rewriteValueWasm_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValueWasm_OpRsh8x32_0(v)
+ return rewriteValueWasm_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValueWasm_OpRsh8x64_0(v)
+ return rewriteValueWasm_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValueWasm_OpRsh8x8_0(v)
+ return rewriteValueWasm_OpRsh8x8(v)
case OpSignExt16to32:
- return rewriteValueWasm_OpSignExt16to32_0(v)
+ return rewriteValueWasm_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValueWasm_OpSignExt16to64_0(v)
+ return rewriteValueWasm_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValueWasm_OpSignExt32to64_0(v)
+ return rewriteValueWasm_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValueWasm_OpSignExt8to16_0(v)
+ return rewriteValueWasm_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValueWasm_OpSignExt8to32_0(v)
+ return rewriteValueWasm_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValueWasm_OpSignExt8to64_0(v)
+ return rewriteValueWasm_OpSignExt8to64(v)
case OpSlicemask:
- return rewriteValueWasm_OpSlicemask_0(v)
+ return rewriteValueWasm_OpSlicemask(v)
case OpSqrt:
- return rewriteValueWasm_OpSqrt_0(v)
+ return rewriteValueWasm_OpSqrt(v)
case OpStaticCall:
- return rewriteValueWasm_OpStaticCall_0(v)
+ return rewriteValueWasm_OpStaticCall(v)
case OpStore:
- return rewriteValueWasm_OpStore_0(v)
+ return rewriteValueWasm_OpStore(v)
case OpSub16:
- return rewriteValueWasm_OpSub16_0(v)
+ return rewriteValueWasm_OpSub16(v)
case OpSub32:
- return rewriteValueWasm_OpSub32_0(v)
+ return rewriteValueWasm_OpSub32(v)
case OpSub32F:
- return rewriteValueWasm_OpSub32F_0(v)
+ return rewriteValueWasm_OpSub32F(v)
case OpSub64:
- return rewriteValueWasm_OpSub64_0(v)
+ return rewriteValueWasm_OpSub64(v)
case OpSub64F:
- return rewriteValueWasm_OpSub64F_0(v)
+ return rewriteValueWasm_OpSub64F(v)
case OpSub8:
- return rewriteValueWasm_OpSub8_0(v)
+ return rewriteValueWasm_OpSub8(v)
case OpSubPtr:
- return rewriteValueWasm_OpSubPtr_0(v)
+ return rewriteValueWasm_OpSubPtr(v)
case OpTrunc:
- return rewriteValueWasm_OpTrunc_0(v)
+ return rewriteValueWasm_OpTrunc(v)
case OpTrunc16to8:
- return rewriteValueWasm_OpTrunc16to8_0(v)
+ return rewriteValueWasm_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValueWasm_OpTrunc32to16_0(v)
+ return rewriteValueWasm_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValueWasm_OpTrunc32to8_0(v)
+ return rewriteValueWasm_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValueWasm_OpTrunc64to16_0(v)
+ return rewriteValueWasm_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValueWasm_OpTrunc64to32_0(v)
+ return rewriteValueWasm_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValueWasm_OpTrunc64to8_0(v)
+ return rewriteValueWasm_OpTrunc64to8(v)
case OpWB:
- return rewriteValueWasm_OpWB_0(v)
+ return rewriteValueWasm_OpWB(v)
case OpWasmF64Add:
- return rewriteValueWasm_OpWasmF64Add_0(v)
+ return rewriteValueWasm_OpWasmF64Add(v)
case OpWasmF64Mul:
- return rewriteValueWasm_OpWasmF64Mul_0(v)
+ return rewriteValueWasm_OpWasmF64Mul(v)
case OpWasmI64Add:
- return rewriteValueWasm_OpWasmI64Add_0(v)
+ return rewriteValueWasm_OpWasmI64Add(v)
case OpWasmI64AddConst:
- return rewriteValueWasm_OpWasmI64AddConst_0(v)
+ return rewriteValueWasm_OpWasmI64AddConst(v)
case OpWasmI64And:
- return rewriteValueWasm_OpWasmI64And_0(v)
+ return rewriteValueWasm_OpWasmI64And(v)
case OpWasmI64Eq:
- return rewriteValueWasm_OpWasmI64Eq_0(v)
+ return rewriteValueWasm_OpWasmI64Eq(v)
case OpWasmI64Eqz:
- return rewriteValueWasm_OpWasmI64Eqz_0(v)
+ return rewriteValueWasm_OpWasmI64Eqz(v)
case OpWasmI64Load:
- return rewriteValueWasm_OpWasmI64Load_0(v)
+ return rewriteValueWasm_OpWasmI64Load(v)
case OpWasmI64Load16S:
- return rewriteValueWasm_OpWasmI64Load16S_0(v)
+ return rewriteValueWasm_OpWasmI64Load16S(v)
case OpWasmI64Load16U:
- return rewriteValueWasm_OpWasmI64Load16U_0(v)
+ return rewriteValueWasm_OpWasmI64Load16U(v)
case OpWasmI64Load32S:
- return rewriteValueWasm_OpWasmI64Load32S_0(v)
+ return rewriteValueWasm_OpWasmI64Load32S(v)
case OpWasmI64Load32U:
- return rewriteValueWasm_OpWasmI64Load32U_0(v)
+ return rewriteValueWasm_OpWasmI64Load32U(v)
case OpWasmI64Load8S:
- return rewriteValueWasm_OpWasmI64Load8S_0(v)
+ return rewriteValueWasm_OpWasmI64Load8S(v)
case OpWasmI64Load8U:
- return rewriteValueWasm_OpWasmI64Load8U_0(v)
+ return rewriteValueWasm_OpWasmI64Load8U(v)
case OpWasmI64Mul:
- return rewriteValueWasm_OpWasmI64Mul_0(v)
+ return rewriteValueWasm_OpWasmI64Mul(v)
case OpWasmI64Ne:
- return rewriteValueWasm_OpWasmI64Ne_0(v)
+ return rewriteValueWasm_OpWasmI64Ne(v)
case OpWasmI64Or:
- return rewriteValueWasm_OpWasmI64Or_0(v)
+ return rewriteValueWasm_OpWasmI64Or(v)
case OpWasmI64Shl:
- return rewriteValueWasm_OpWasmI64Shl_0(v)
+ return rewriteValueWasm_OpWasmI64Shl(v)
case OpWasmI64ShrS:
- return rewriteValueWasm_OpWasmI64ShrS_0(v)
+ return rewriteValueWasm_OpWasmI64ShrS(v)
case OpWasmI64ShrU:
- return rewriteValueWasm_OpWasmI64ShrU_0(v)
+ return rewriteValueWasm_OpWasmI64ShrU(v)
case OpWasmI64Store:
- return rewriteValueWasm_OpWasmI64Store_0(v)
+ return rewriteValueWasm_OpWasmI64Store(v)
case OpWasmI64Store16:
- return rewriteValueWasm_OpWasmI64Store16_0(v)
+ return rewriteValueWasm_OpWasmI64Store16(v)
case OpWasmI64Store32:
- return rewriteValueWasm_OpWasmI64Store32_0(v)
+ return rewriteValueWasm_OpWasmI64Store32(v)
case OpWasmI64Store8:
- return rewriteValueWasm_OpWasmI64Store8_0(v)
+ return rewriteValueWasm_OpWasmI64Store8(v)
case OpWasmI64Xor:
- return rewriteValueWasm_OpWasmI64Xor_0(v)
+ return rewriteValueWasm_OpWasmI64Xor(v)
case OpXor16:
- return rewriteValueWasm_OpXor16_0(v)
+ return rewriteValueWasm_OpXor16(v)
case OpXor32:
- return rewriteValueWasm_OpXor32_0(v)
+ return rewriteValueWasm_OpXor32(v)
case OpXor64:
- return rewriteValueWasm_OpXor64_0(v)
+ return rewriteValueWasm_OpXor64(v)
case OpXor8:
- return rewriteValueWasm_OpXor8_0(v)
+ return rewriteValueWasm_OpXor8(v)
case OpZero:
- return rewriteValueWasm_OpZero_0(v) || rewriteValueWasm_OpZero_10(v)
+ return rewriteValueWasm_OpZero(v)
case OpZeroExt16to32:
- return rewriteValueWasm_OpZeroExt16to32_0(v)
+ return rewriteValueWasm_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValueWasm_OpZeroExt16to64_0(v)
+ return rewriteValueWasm_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValueWasm_OpZeroExt32to64_0(v)
+ return rewriteValueWasm_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValueWasm_OpZeroExt8to16_0(v)
+ return rewriteValueWasm_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValueWasm_OpZeroExt8to32_0(v)
+ return rewriteValueWasm_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValueWasm_OpZeroExt8to64_0(v)
+ return rewriteValueWasm_OpZeroExt8to64(v)
}
return false
}
-func rewriteValueWasm_OpAbs_0(v *Value) bool {
+func rewriteValueWasm_OpAbs(v *Value) bool {
v_0 := v.Args[0]
// match: (Abs x)
// result: (F64Abs x)
@@ -588,7 +588,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd16_0(v *Value) bool {
+func rewriteValueWasm_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add16 x y)
@@ -602,7 +602,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd32_0(v *Value) bool {
+func rewriteValueWasm_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32 x y)
@@ -616,7 +616,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd32F_0(v *Value) bool {
+func rewriteValueWasm_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F x y)
@@ -630,7 +630,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd64_0(v *Value) bool {
+func rewriteValueWasm_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64 x y)
@@ -644,7 +644,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd64F_0(v *Value) bool {
+func rewriteValueWasm_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F x y)
@@ -658,7 +658,7 @@
return true
}
}
-func rewriteValueWasm_OpAdd8_0(v *Value) bool {
+func rewriteValueWasm_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add8 x y)
@@ -672,7 +672,7 @@
return true
}
}
-func rewriteValueWasm_OpAddPtr_0(v *Value) bool {
+func rewriteValueWasm_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr x y)
@@ -686,7 +686,7 @@
return true
}
}
-func rewriteValueWasm_OpAddr_0(v *Value) bool {
+func rewriteValueWasm_OpAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (Addr {sym} base)
// result: (LoweredAddr {sym} base)
@@ -699,7 +699,7 @@
return true
}
}
-func rewriteValueWasm_OpAnd16_0(v *Value) bool {
+func rewriteValueWasm_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And16 x y)
@@ -713,7 +713,7 @@
return true
}
}
-func rewriteValueWasm_OpAnd32_0(v *Value) bool {
+func rewriteValueWasm_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And32 x y)
@@ -727,7 +727,7 @@
return true
}
}
-func rewriteValueWasm_OpAnd64_0(v *Value) bool {
+func rewriteValueWasm_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And64 x y)
@@ -741,7 +741,7 @@
return true
}
}
-func rewriteValueWasm_OpAnd8_0(v *Value) bool {
+func rewriteValueWasm_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (And8 x y)
@@ -755,7 +755,7 @@
return true
}
}
-func rewriteValueWasm_OpAndB_0(v *Value) bool {
+func rewriteValueWasm_OpAndB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AndB x y)
@@ -769,7 +769,7 @@
return true
}
}
-func rewriteValueWasm_OpBitLen64_0(v *Value) bool {
+func rewriteValueWasm_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -787,7 +787,7 @@
return true
}
}
-func rewriteValueWasm_OpCeil_0(v *Value) bool {
+func rewriteValueWasm_OpCeil(v *Value) bool {
v_0 := v.Args[0]
// match: (Ceil x)
// result: (F64Ceil x)
@@ -798,7 +798,7 @@
return true
}
}
-func rewriteValueWasm_OpClosureCall_0(v *Value) bool {
+func rewriteValueWasm_OpClosureCall(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -817,7 +817,7 @@
return true
}
}
-func rewriteValueWasm_OpCom16_0(v *Value) bool {
+func rewriteValueWasm_OpCom16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -833,7 +833,7 @@
return true
}
}
-func rewriteValueWasm_OpCom32_0(v *Value) bool {
+func rewriteValueWasm_OpCom32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -849,7 +849,7 @@
return true
}
}
-func rewriteValueWasm_OpCom64_0(v *Value) bool {
+func rewriteValueWasm_OpCom64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -865,7 +865,7 @@
return true
}
}
-func rewriteValueWasm_OpCom8_0(v *Value) bool {
+func rewriteValueWasm_OpCom8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -881,7 +881,7 @@
return true
}
}
-func rewriteValueWasm_OpCondSelect_0(v *Value) bool {
+func rewriteValueWasm_OpCondSelect(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -900,7 +900,7 @@
return true
}
}
-func rewriteValueWasm_OpConst16_0(v *Value) bool {
+func rewriteValueWasm_OpConst16(v *Value) bool {
// match: (Const16 [val])
// result: (I64Const [val])
for {
@@ -910,7 +910,7 @@
return true
}
}
-func rewriteValueWasm_OpConst32_0(v *Value) bool {
+func rewriteValueWasm_OpConst32(v *Value) bool {
// match: (Const32 [val])
// result: (I64Const [val])
for {
@@ -920,7 +920,7 @@
return true
}
}
-func rewriteValueWasm_OpConst32F_0(v *Value) bool {
+func rewriteValueWasm_OpConst32F(v *Value) bool {
// match: (Const32F [val])
// result: (F32Const [val])
for {
@@ -930,7 +930,7 @@
return true
}
}
-func rewriteValueWasm_OpConst64_0(v *Value) bool {
+func rewriteValueWasm_OpConst64(v *Value) bool {
// match: (Const64 [val])
// result: (I64Const [val])
for {
@@ -940,7 +940,7 @@
return true
}
}
-func rewriteValueWasm_OpConst64F_0(v *Value) bool {
+func rewriteValueWasm_OpConst64F(v *Value) bool {
// match: (Const64F [val])
// result: (F64Const [val])
for {
@@ -950,7 +950,7 @@
return true
}
}
-func rewriteValueWasm_OpConst8_0(v *Value) bool {
+func rewriteValueWasm_OpConst8(v *Value) bool {
// match: (Const8 [val])
// result: (I64Const [val])
for {
@@ -960,7 +960,7 @@
return true
}
}
-func rewriteValueWasm_OpConstBool_0(v *Value) bool {
+func rewriteValueWasm_OpConstBool(v *Value) bool {
// match: (ConstBool [b])
// result: (I64Const [b])
for {
@@ -970,7 +970,7 @@
return true
}
}
-func rewriteValueWasm_OpConstNil_0(v *Value) bool {
+func rewriteValueWasm_OpConstNil(v *Value) bool {
// match: (ConstNil)
// result: (I64Const [0])
for {
@@ -979,7 +979,7 @@
return true
}
}
-func rewriteValueWasm_OpConvert_0(v *Value) bool {
+func rewriteValueWasm_OpConvert(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Convert <t> x mem)
@@ -995,7 +995,7 @@
return true
}
}
-func rewriteValueWasm_OpCopysign_0(v *Value) bool {
+func rewriteValueWasm_OpCopysign(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Copysign x y)
@@ -1009,7 +1009,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz16_0(v *Value) bool {
+func rewriteValueWasm_OpCtz16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1027,7 +1027,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz16NonZero_0(v *Value) bool {
+func rewriteValueWasm_OpCtz16NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz16NonZero x)
// result: (I64Ctz x)
@@ -1038,7 +1038,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz32_0(v *Value) bool {
+func rewriteValueWasm_OpCtz32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1056,7 +1056,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz32NonZero_0(v *Value) bool {
+func rewriteValueWasm_OpCtz32NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz32NonZero x)
// result: (I64Ctz x)
@@ -1067,7 +1067,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz64_0(v *Value) bool {
+func rewriteValueWasm_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64 x)
// result: (I64Ctz x)
@@ -1078,7 +1078,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValueWasm_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64NonZero x)
// result: (I64Ctz x)
@@ -1089,7 +1089,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz8_0(v *Value) bool {
+func rewriteValueWasm_OpCtz8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1107,7 +1107,7 @@
return true
}
}
-func rewriteValueWasm_OpCtz8NonZero_0(v *Value) bool {
+func rewriteValueWasm_OpCtz8NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz8NonZero x)
// result: (I64Ctz x)
@@ -1118,7 +1118,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 x)
// result: (I64TruncSatF32S x)
@@ -1129,7 +1129,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32U x)
// result: (I64TruncSatF32U x)
@@ -1140,7 +1140,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 x)
// result: (I64TruncSatF32S x)
@@ -1151,7 +1151,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F x)
// result: (F64PromoteF32 x)
@@ -1162,7 +1162,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Fto64U_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Fto64U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64U x)
// result: (I64TruncSatF32U x)
@@ -1173,7 +1173,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Uto32F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Uto32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1188,7 +1188,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32Uto64F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32Uto64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1203,7 +1203,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32to32F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1218,7 +1218,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -1233,7 +1233,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 x)
// result: (I64TruncSatF64S x)
@@ -1244,7 +1244,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F x)
// result: (F32DemoteF64 x)
@@ -1255,7 +1255,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Fto32U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32U x)
// result: (I64TruncSatF64U x)
@@ -1266,7 +1266,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 x)
// result: (I64TruncSatF64S x)
@@ -1277,7 +1277,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Fto64U_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Fto64U(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64U x)
// result: (I64TruncSatF64U x)
@@ -1288,7 +1288,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Uto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Uto32F x)
// result: (F32ConvertI64U x)
@@ -1299,7 +1299,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64Uto64F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64Uto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Uto64F x)
// result: (F64ConvertI64U x)
@@ -1310,7 +1310,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F x)
// result: (F32ConvertI64S x)
@@ -1321,7 +1321,7 @@
return true
}
}
-func rewriteValueWasm_OpCvt64to64F_0(v *Value) bool {
+func rewriteValueWasm_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F x)
// result: (F64ConvertI64S x)
@@ -1332,7 +1332,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv16_0(v *Value) bool {
+func rewriteValueWasm_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1352,7 +1352,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv16u_0(v *Value) bool {
+func rewriteValueWasm_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1372,7 +1372,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv32_0(v *Value) bool {
+func rewriteValueWasm_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1392,7 +1392,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv32F_0(v *Value) bool {
+func rewriteValueWasm_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div32F x y)
@@ -1406,7 +1406,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv32u_0(v *Value) bool {
+func rewriteValueWasm_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1426,7 +1426,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv64_0(v *Value) bool {
+func rewriteValueWasm_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64 x y)
@@ -1440,7 +1440,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv64F_0(v *Value) bool {
+func rewriteValueWasm_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64F x y)
@@ -1454,7 +1454,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv64u_0(v *Value) bool {
+func rewriteValueWasm_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Div64u x y)
@@ -1468,7 +1468,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv8_0(v *Value) bool {
+func rewriteValueWasm_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1488,7 +1488,7 @@
return true
}
}
-func rewriteValueWasm_OpDiv8u_0(v *Value) bool {
+func rewriteValueWasm_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1508,7 +1508,7 @@
return true
}
}
-func rewriteValueWasm_OpEq16_0(v *Value) bool {
+func rewriteValueWasm_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1528,7 +1528,7 @@
return true
}
}
-func rewriteValueWasm_OpEq32_0(v *Value) bool {
+func rewriteValueWasm_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1548,7 +1548,7 @@
return true
}
}
-func rewriteValueWasm_OpEq32F_0(v *Value) bool {
+func rewriteValueWasm_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq32F x y)
@@ -1562,7 +1562,7 @@
return true
}
}
-func rewriteValueWasm_OpEq64_0(v *Value) bool {
+func rewriteValueWasm_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq64 x y)
@@ -1576,7 +1576,7 @@
return true
}
}
-func rewriteValueWasm_OpEq64F_0(v *Value) bool {
+func rewriteValueWasm_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq64F x y)
@@ -1590,7 +1590,7 @@
return true
}
}
-func rewriteValueWasm_OpEq8_0(v *Value) bool {
+func rewriteValueWasm_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1610,7 +1610,7 @@
return true
}
}
-func rewriteValueWasm_OpEqB_0(v *Value) bool {
+func rewriteValueWasm_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqB x y)
@@ -1624,7 +1624,7 @@
return true
}
}
-func rewriteValueWasm_OpEqPtr_0(v *Value) bool {
+func rewriteValueWasm_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqPtr x y)
@@ -1638,7 +1638,7 @@
return true
}
}
-func rewriteValueWasm_OpFloor_0(v *Value) bool {
+func rewriteValueWasm_OpFloor(v *Value) bool {
v_0 := v.Args[0]
// match: (Floor x)
// result: (F64Floor x)
@@ -1649,7 +1649,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq16_0(v *Value) bool {
+func rewriteValueWasm_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1669,7 +1669,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq16U_0(v *Value) bool {
+func rewriteValueWasm_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1689,7 +1689,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq32_0(v *Value) bool {
+func rewriteValueWasm_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1709,7 +1709,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq32F_0(v *Value) bool {
+func rewriteValueWasm_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq32F x y)
@@ -1723,7 +1723,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq32U_0(v *Value) bool {
+func rewriteValueWasm_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1743,7 +1743,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq64_0(v *Value) bool {
+func rewriteValueWasm_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64 x y)
@@ -1757,7 +1757,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq64F_0(v *Value) bool {
+func rewriteValueWasm_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64F x y)
@@ -1771,7 +1771,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq64U_0(v *Value) bool {
+func rewriteValueWasm_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64U x y)
@@ -1785,7 +1785,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq8_0(v *Value) bool {
+func rewriteValueWasm_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1805,7 +1805,7 @@
return true
}
}
-func rewriteValueWasm_OpGeq8U_0(v *Value) bool {
+func rewriteValueWasm_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1825,7 +1825,7 @@
return true
}
}
-func rewriteValueWasm_OpGetCallerPC_0(v *Value) bool {
+func rewriteValueWasm_OpGetCallerPC(v *Value) bool {
// match: (GetCallerPC)
// result: (LoweredGetCallerPC)
for {
@@ -1833,7 +1833,7 @@
return true
}
}
-func rewriteValueWasm_OpGetCallerSP_0(v *Value) bool {
+func rewriteValueWasm_OpGetCallerSP(v *Value) bool {
// match: (GetCallerSP)
// result: (LoweredGetCallerSP)
for {
@@ -1841,7 +1841,7 @@
return true
}
}
-func rewriteValueWasm_OpGetClosurePtr_0(v *Value) bool {
+func rewriteValueWasm_OpGetClosurePtr(v *Value) bool {
// match: (GetClosurePtr)
// result: (LoweredGetClosurePtr)
for {
@@ -1849,7 +1849,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater16_0(v *Value) bool {
+func rewriteValueWasm_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1869,7 +1869,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater16U_0(v *Value) bool {
+func rewriteValueWasm_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1889,7 +1889,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater32_0(v *Value) bool {
+func rewriteValueWasm_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1909,7 +1909,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater32F_0(v *Value) bool {
+func rewriteValueWasm_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32F x y)
@@ -1923,7 +1923,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater32U_0(v *Value) bool {
+func rewriteValueWasm_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1943,7 +1943,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater64_0(v *Value) bool {
+func rewriteValueWasm_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64 x y)
@@ -1957,7 +1957,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater64F_0(v *Value) bool {
+func rewriteValueWasm_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64F x y)
@@ -1971,7 +1971,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater64U_0(v *Value) bool {
+func rewriteValueWasm_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64U x y)
@@ -1985,7 +1985,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater8_0(v *Value) bool {
+func rewriteValueWasm_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2005,7 +2005,7 @@
return true
}
}
-func rewriteValueWasm_OpGreater8U_0(v *Value) bool {
+func rewriteValueWasm_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2025,7 +2025,7 @@
return true
}
}
-func rewriteValueWasm_OpInterCall_0(v *Value) bool {
+func rewriteValueWasm_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argwid] entry mem)
@@ -2041,7 +2041,7 @@
return true
}
}
-func rewriteValueWasm_OpIsInBounds_0(v *Value) bool {
+func rewriteValueWasm_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds idx len)
@@ -2055,7 +2055,7 @@
return true
}
}
-func rewriteValueWasm_OpIsNonNil_0(v *Value) bool {
+func rewriteValueWasm_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2070,7 +2070,7 @@
return true
}
}
-func rewriteValueWasm_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValueWasm_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsSliceInBounds idx len)
@@ -2084,7 +2084,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq16_0(v *Value) bool {
+func rewriteValueWasm_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2104,7 +2104,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq16U_0(v *Value) bool {
+func rewriteValueWasm_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2124,7 +2124,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq32_0(v *Value) bool {
+func rewriteValueWasm_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2144,7 +2144,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq32F_0(v *Value) bool {
+func rewriteValueWasm_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32F x y)
@@ -2158,7 +2158,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq32U_0(v *Value) bool {
+func rewriteValueWasm_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2178,7 +2178,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq64_0(v *Value) bool {
+func rewriteValueWasm_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64 x y)
@@ -2192,7 +2192,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq64F_0(v *Value) bool {
+func rewriteValueWasm_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64F x y)
@@ -2206,7 +2206,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq64U_0(v *Value) bool {
+func rewriteValueWasm_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64U x y)
@@ -2220,7 +2220,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq8_0(v *Value) bool {
+func rewriteValueWasm_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2240,7 +2240,7 @@
return true
}
}
-func rewriteValueWasm_OpLeq8U_0(v *Value) bool {
+func rewriteValueWasm_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2260,7 +2260,7 @@
return true
}
}
-func rewriteValueWasm_OpLess16_0(v *Value) bool {
+func rewriteValueWasm_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2280,7 +2280,7 @@
return true
}
}
-func rewriteValueWasm_OpLess16U_0(v *Value) bool {
+func rewriteValueWasm_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2300,7 +2300,7 @@
return true
}
}
-func rewriteValueWasm_OpLess32_0(v *Value) bool {
+func rewriteValueWasm_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2320,7 +2320,7 @@
return true
}
}
-func rewriteValueWasm_OpLess32F_0(v *Value) bool {
+func rewriteValueWasm_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32F x y)
@@ -2334,7 +2334,7 @@
return true
}
}
-func rewriteValueWasm_OpLess32U_0(v *Value) bool {
+func rewriteValueWasm_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2354,7 +2354,7 @@
return true
}
}
-func rewriteValueWasm_OpLess64_0(v *Value) bool {
+func rewriteValueWasm_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 x y)
@@ -2368,7 +2368,7 @@
return true
}
}
-func rewriteValueWasm_OpLess64F_0(v *Value) bool {
+func rewriteValueWasm_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64F x y)
@@ -2382,7 +2382,7 @@
return true
}
}
-func rewriteValueWasm_OpLess64U_0(v *Value) bool {
+func rewriteValueWasm_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U x y)
@@ -2396,7 +2396,7 @@
return true
}
}
-func rewriteValueWasm_OpLess8_0(v *Value) bool {
+func rewriteValueWasm_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2416,7 +2416,7 @@
return true
}
}
-func rewriteValueWasm_OpLess8U_0(v *Value) bool {
+func rewriteValueWasm_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2436,7 +2436,7 @@
return true
}
}
-func rewriteValueWasm_OpLoad_0(v *Value) bool {
+func rewriteValueWasm_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Load <t> ptr mem)
@@ -2576,7 +2576,7 @@
}
return false
}
-func rewriteValueWasm_OpLocalAddr_0(v *Value) bool {
+func rewriteValueWasm_OpLocalAddr(v *Value) bool {
v_0 := v.Args[0]
// match: (LocalAddr {sym} base _)
// result: (LoweredAddr {sym} base)
@@ -2589,7 +2589,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x16_0(v *Value) bool {
+func rewriteValueWasm_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2607,7 +2607,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x32_0(v *Value) bool {
+func rewriteValueWasm_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2625,7 +2625,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x64_0(v *Value) bool {
+func rewriteValueWasm_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh16x64 x y)
@@ -2639,7 +2639,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh16x8_0(v *Value) bool {
+func rewriteValueWasm_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2657,7 +2657,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x16_0(v *Value) bool {
+func rewriteValueWasm_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2675,7 +2675,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x32_0(v *Value) bool {
+func rewriteValueWasm_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2693,7 +2693,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x64_0(v *Value) bool {
+func rewriteValueWasm_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh32x64 x y)
@@ -2707,7 +2707,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh32x8_0(v *Value) bool {
+func rewriteValueWasm_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2725,7 +2725,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x16_0(v *Value) bool {
+func rewriteValueWasm_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2743,7 +2743,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x32_0(v *Value) bool {
+func rewriteValueWasm_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2761,7 +2761,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x64_0(v *Value) bool {
+func rewriteValueWasm_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2836,7 +2836,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh64x8_0(v *Value) bool {
+func rewriteValueWasm_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2854,7 +2854,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x16_0(v *Value) bool {
+func rewriteValueWasm_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2872,7 +2872,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x32_0(v *Value) bool {
+func rewriteValueWasm_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2890,7 +2890,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x64_0(v *Value) bool {
+func rewriteValueWasm_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Lsh8x64 x y)
@@ -2904,7 +2904,7 @@
return true
}
}
-func rewriteValueWasm_OpLsh8x8_0(v *Value) bool {
+func rewriteValueWasm_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2922,7 +2922,7 @@
return true
}
}
-func rewriteValueWasm_OpMod16_0(v *Value) bool {
+func rewriteValueWasm_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2942,7 +2942,7 @@
return true
}
}
-func rewriteValueWasm_OpMod16u_0(v *Value) bool {
+func rewriteValueWasm_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2962,7 +2962,7 @@
return true
}
}
-func rewriteValueWasm_OpMod32_0(v *Value) bool {
+func rewriteValueWasm_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2982,7 +2982,7 @@
return true
}
}
-func rewriteValueWasm_OpMod32u_0(v *Value) bool {
+func rewriteValueWasm_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3002,7 +3002,7 @@
return true
}
}
-func rewriteValueWasm_OpMod64_0(v *Value) bool {
+func rewriteValueWasm_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64 x y)
@@ -3016,7 +3016,7 @@
return true
}
}
-func rewriteValueWasm_OpMod64u_0(v *Value) bool {
+func rewriteValueWasm_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mod64u x y)
@@ -3030,7 +3030,7 @@
return true
}
}
-func rewriteValueWasm_OpMod8_0(v *Value) bool {
+func rewriteValueWasm_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3050,7 +3050,7 @@
return true
}
}
-func rewriteValueWasm_OpMod8u_0(v *Value) bool {
+func rewriteValueWasm_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3070,7 +3070,7 @@
return true
}
}
-func rewriteValueWasm_OpMove_0(v *Value) bool {
+func rewriteValueWasm_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -3295,14 +3295,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueWasm_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Move [s] dst src mem)
// cond: s > 8 && s < 16
// result: (I64Store [s-8] dst (I64Load [s-8] src mem) (I64Store dst (I64Load src mem) mem))
@@ -3423,7 +3415,7 @@
}
return false
}
-func rewriteValueWasm_OpMul16_0(v *Value) bool {
+func rewriteValueWasm_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul16 x y)
@@ -3437,7 +3429,7 @@
return true
}
}
-func rewriteValueWasm_OpMul32_0(v *Value) bool {
+func rewriteValueWasm_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32 x y)
@@ -3451,7 +3443,7 @@
return true
}
}
-func rewriteValueWasm_OpMul32F_0(v *Value) bool {
+func rewriteValueWasm_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F x y)
@@ -3465,7 +3457,7 @@
return true
}
}
-func rewriteValueWasm_OpMul64_0(v *Value) bool {
+func rewriteValueWasm_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64 x y)
@@ -3479,7 +3471,7 @@
return true
}
}
-func rewriteValueWasm_OpMul64F_0(v *Value) bool {
+func rewriteValueWasm_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F x y)
@@ -3493,7 +3485,7 @@
return true
}
}
-func rewriteValueWasm_OpMul8_0(v *Value) bool {
+func rewriteValueWasm_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul8 x y)
@@ -3507,7 +3499,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg16_0(v *Value) bool {
+func rewriteValueWasm_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3523,7 +3515,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg32_0(v *Value) bool {
+func rewriteValueWasm_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3539,7 +3531,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg32F_0(v *Value) bool {
+func rewriteValueWasm_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F x)
// result: (F32Neg x)
@@ -3550,7 +3542,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg64_0(v *Value) bool {
+func rewriteValueWasm_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3566,7 +3558,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg64F_0(v *Value) bool {
+func rewriteValueWasm_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F x)
// result: (F64Neg x)
@@ -3577,7 +3569,7 @@
return true
}
}
-func rewriteValueWasm_OpNeg8_0(v *Value) bool {
+func rewriteValueWasm_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3593,7 +3585,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq16_0(v *Value) bool {
+func rewriteValueWasm_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3613,7 +3605,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq32_0(v *Value) bool {
+func rewriteValueWasm_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3633,7 +3625,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq32F_0(v *Value) bool {
+func rewriteValueWasm_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq32F x y)
@@ -3647,7 +3639,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq64_0(v *Value) bool {
+func rewriteValueWasm_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq64 x y)
@@ -3661,7 +3653,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq64F_0(v *Value) bool {
+func rewriteValueWasm_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq64F x y)
@@ -3675,7 +3667,7 @@
return true
}
}
-func rewriteValueWasm_OpNeq8_0(v *Value) bool {
+func rewriteValueWasm_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3695,7 +3687,7 @@
return true
}
}
-func rewriteValueWasm_OpNeqB_0(v *Value) bool {
+func rewriteValueWasm_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB x y)
@@ -3709,7 +3701,7 @@
return true
}
}
-func rewriteValueWasm_OpNeqPtr_0(v *Value) bool {
+func rewriteValueWasm_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqPtr x y)
@@ -3723,7 +3715,7 @@
return true
}
}
-func rewriteValueWasm_OpNilCheck_0(v *Value) bool {
+func rewriteValueWasm_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NilCheck ptr mem)
@@ -3737,7 +3729,7 @@
return true
}
}
-func rewriteValueWasm_OpNot_0(v *Value) bool {
+func rewriteValueWasm_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not x)
// result: (I64Eqz x)
@@ -3748,7 +3740,7 @@
return true
}
}
-func rewriteValueWasm_OpOffPtr_0(v *Value) bool {
+func rewriteValueWasm_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr [off] ptr)
// result: (I64AddConst [off] ptr)
@@ -3761,7 +3753,7 @@
return true
}
}
-func rewriteValueWasm_OpOr16_0(v *Value) bool {
+func rewriteValueWasm_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or16 x y)
@@ -3775,7 +3767,7 @@
return true
}
}
-func rewriteValueWasm_OpOr32_0(v *Value) bool {
+func rewriteValueWasm_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or32 x y)
@@ -3789,7 +3781,7 @@
return true
}
}
-func rewriteValueWasm_OpOr64_0(v *Value) bool {
+func rewriteValueWasm_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or64 x y)
@@ -3803,7 +3795,7 @@
return true
}
}
-func rewriteValueWasm_OpOr8_0(v *Value) bool {
+func rewriteValueWasm_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Or8 x y)
@@ -3817,7 +3809,7 @@
return true
}
}
-func rewriteValueWasm_OpOrB_0(v *Value) bool {
+func rewriteValueWasm_OpOrB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (OrB x y)
@@ -3831,7 +3823,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount16_0(v *Value) bool {
+func rewriteValueWasm_OpPopCount16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3846,7 +3838,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount32_0(v *Value) bool {
+func rewriteValueWasm_OpPopCount32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3861,7 +3853,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount64_0(v *Value) bool {
+func rewriteValueWasm_OpPopCount64(v *Value) bool {
v_0 := v.Args[0]
// match: (PopCount64 x)
// result: (I64Popcnt x)
@@ -3872,7 +3864,7 @@
return true
}
}
-func rewriteValueWasm_OpPopCount8_0(v *Value) bool {
+func rewriteValueWasm_OpPopCount8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -3887,7 +3879,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateLeft16_0(v *Value) bool {
+func rewriteValueWasm_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3918,7 +3910,7 @@
}
return false
}
-func rewriteValueWasm_OpRotateLeft32_0(v *Value) bool {
+func rewriteValueWasm_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x y)
@@ -3932,7 +3924,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateLeft64_0(v *Value) bool {
+func rewriteValueWasm_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft64 x y)
@@ -3946,7 +3938,7 @@
return true
}
}
-func rewriteValueWasm_OpRotateLeft8_0(v *Value) bool {
+func rewriteValueWasm_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3977,7 +3969,7 @@
}
return false
}
-func rewriteValueWasm_OpRound32F_0(v *Value) bool {
+func rewriteValueWasm_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x)
// result: x
@@ -3989,7 +3981,7 @@
return true
}
}
-func rewriteValueWasm_OpRound64F_0(v *Value) bool {
+func rewriteValueWasm_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x)
// result: x
@@ -4001,7 +3993,7 @@
return true
}
}
-func rewriteValueWasm_OpRoundToEven_0(v *Value) bool {
+func rewriteValueWasm_OpRoundToEven(v *Value) bool {
v_0 := v.Args[0]
// match: (RoundToEven x)
// result: (F64Nearest x)
@@ -4012,7 +4004,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4032,7 +4024,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4052,7 +4044,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4070,7 +4062,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4090,7 +4082,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4110,7 +4102,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4130,7 +4122,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4148,7 +4140,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh16x8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4168,7 +4160,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4188,7 +4180,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4208,7 +4200,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4226,7 +4218,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4246,7 +4238,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4266,7 +4258,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4286,7 +4278,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4304,7 +4296,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh32x8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4324,7 +4316,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4342,7 +4334,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4360,7 +4352,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4435,7 +4427,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4453,7 +4445,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4471,7 +4463,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4489,7 +4481,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4568,7 +4560,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh64x8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4586,7 +4578,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4606,7 +4598,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4626,7 +4618,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4644,7 +4636,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4664,7 +4656,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x16_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4684,7 +4676,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x32_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4704,7 +4696,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x64_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4722,7 +4714,7 @@
return true
}
}
-func rewriteValueWasm_OpRsh8x8_0(v *Value) bool {
+func rewriteValueWasm_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4742,7 +4734,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt16to32_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4788,7 +4780,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt16to64_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4834,7 +4826,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt32to64_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4880,7 +4872,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to16_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4926,7 +4918,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to32_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -4972,7 +4964,7 @@
return true
}
}
-func rewriteValueWasm_OpSignExt8to64_0(v *Value) bool {
+func rewriteValueWasm_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5018,7 +5010,7 @@
return true
}
}
-func rewriteValueWasm_OpSlicemask_0(v *Value) bool {
+func rewriteValueWasm_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -5039,7 +5031,7 @@
return true
}
}
-func rewriteValueWasm_OpSqrt_0(v *Value) bool {
+func rewriteValueWasm_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt x)
// result: (F64Sqrt x)
@@ -5050,7 +5042,7 @@
return true
}
}
-func rewriteValueWasm_OpStaticCall_0(v *Value) bool {
+func rewriteValueWasm_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
// match: (StaticCall [argwid] {target} mem)
// result: (LoweredStaticCall [argwid] {target} mem)
@@ -5065,7 +5057,7 @@
return true
}
}
-func rewriteValueWasm_OpStore_0(v *Value) bool {
+func rewriteValueWasm_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5173,7 +5165,7 @@
}
return false
}
-func rewriteValueWasm_OpSub16_0(v *Value) bool {
+func rewriteValueWasm_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub16 x y)
@@ -5187,7 +5179,7 @@
return true
}
}
-func rewriteValueWasm_OpSub32_0(v *Value) bool {
+func rewriteValueWasm_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32 x y)
@@ -5201,7 +5193,7 @@
return true
}
}
-func rewriteValueWasm_OpSub32F_0(v *Value) bool {
+func rewriteValueWasm_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F x y)
@@ -5215,7 +5207,7 @@
return true
}
}
-func rewriteValueWasm_OpSub64_0(v *Value) bool {
+func rewriteValueWasm_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64 x y)
@@ -5229,7 +5221,7 @@
return true
}
}
-func rewriteValueWasm_OpSub64F_0(v *Value) bool {
+func rewriteValueWasm_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F x y)
@@ -5243,7 +5235,7 @@
return true
}
}
-func rewriteValueWasm_OpSub8_0(v *Value) bool {
+func rewriteValueWasm_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub8 x y)
@@ -5257,7 +5249,7 @@
return true
}
}
-func rewriteValueWasm_OpSubPtr_0(v *Value) bool {
+func rewriteValueWasm_OpSubPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (SubPtr x y)
@@ -5271,7 +5263,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc x)
// result: (F64Trunc x)
@@ -5282,7 +5274,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc16to8_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 x)
// result: x
@@ -5294,7 +5286,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc32to16_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 x)
// result: x
@@ -5306,7 +5298,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc32to8_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 x)
// result: x
@@ -5318,7 +5310,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc64to16_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 x)
// result: x
@@ -5330,7 +5322,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc64to32_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 x)
// result: x
@@ -5342,7 +5334,7 @@
return true
}
}
-func rewriteValueWasm_OpTrunc64to8_0(v *Value) bool {
+func rewriteValueWasm_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 x)
// result: x
@@ -5354,7 +5346,7 @@
return true
}
}
-func rewriteValueWasm_OpWB_0(v *Value) bool {
+func rewriteValueWasm_OpWB(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -5373,7 +5365,7 @@
return true
}
}
-func rewriteValueWasm_OpWasmF64Add_0(v *Value) bool {
+func rewriteValueWasm_OpWasmF64Add(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5410,7 +5402,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmF64Mul_0(v *Value) bool {
+func rewriteValueWasm_OpWasmF64Mul(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5447,7 +5439,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Add_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Add(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5497,7 +5489,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64AddConst_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64AddConst(v *Value) bool {
v_0 := v.Args[0]
// match: (I64AddConst [0] x)
// result: x
@@ -5533,7 +5525,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64And_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64And(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5570,7 +5562,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Eq_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Eq(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5641,7 +5633,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Eqz_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Eqz(v *Value) bool {
v_0 := v.Args[0]
// match: (I64Eqz (I64Eqz (I64Eqz x)))
// result: (I64Eqz x)
@@ -5660,7 +5652,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5705,7 +5697,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load16S_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load16S(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load16S [off] (I64AddConst [off2] ptr) mem)
@@ -5730,7 +5722,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load16U_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5775,7 +5767,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load32S_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load32S(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load32S [off] (I64AddConst [off2] ptr) mem)
@@ -5800,7 +5792,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load32U_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5845,7 +5837,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load8S_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load8S(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load8S [off] (I64AddConst [off2] ptr) mem)
@@ -5870,7 +5862,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Load8U_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Load8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Load8U [off] (I64AddConst [off2] ptr) mem)
@@ -5913,7 +5905,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Mul_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Mul(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5950,7 +5942,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Ne_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Ne(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6023,7 +6015,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Or_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Or(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6060,7 +6052,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Shl_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Shl(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64Shl (I64Const [x]) (I64Const [y]))
@@ -6080,7 +6072,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64ShrS_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64ShrS(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64ShrS (I64Const [x]) (I64Const [y]))
@@ -6100,7 +6092,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64ShrU_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64ShrU(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (I64ShrU (I64Const [x]) (I64Const [y]))
@@ -6120,7 +6112,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Store(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6148,7 +6140,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store16_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Store16(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6176,7 +6168,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store32_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Store32(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6204,7 +6196,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Store8_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Store8(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -6232,7 +6224,7 @@
}
return false
}
-func rewriteValueWasm_OpWasmI64Xor_0(v *Value) bool {
+func rewriteValueWasm_OpWasmI64Xor(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6269,7 +6261,7 @@
}
return false
}
-func rewriteValueWasm_OpXor16_0(v *Value) bool {
+func rewriteValueWasm_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor16 x y)
@@ -6283,7 +6275,7 @@
return true
}
}
-func rewriteValueWasm_OpXor32_0(v *Value) bool {
+func rewriteValueWasm_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor32 x y)
@@ -6297,7 +6289,7 @@
return true
}
}
-func rewriteValueWasm_OpXor64_0(v *Value) bool {
+func rewriteValueWasm_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor64 x y)
@@ -6311,7 +6303,7 @@
return true
}
}
-func rewriteValueWasm_OpXor8_0(v *Value) bool {
+func rewriteValueWasm_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Xor8 x y)
@@ -6325,7 +6317,7 @@
return true
}
}
-func rewriteValueWasm_OpZero_0(v *Value) bool {
+func rewriteValueWasm_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6523,13 +6515,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValueWasm_OpZero_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Zero [16] destptr mem)
// result: (I64Store [8] destptr (I64Const [0]) (I64Store destptr (I64Const [0]) mem))
for {
@@ -6638,7 +6623,7 @@
}
return false
}
-func rewriteValueWasm_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6667,7 +6652,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6696,7 +6681,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6725,7 +6710,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6754,7 +6739,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -6783,7 +6768,7 @@
return true
}
}
-func rewriteValueWasm_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValueWasm_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go
index 1d1dac7..9393cad 100644
--- a/src/cmd/compile/internal/ssa/rewritedec.go
+++ b/src/cmd/compile/internal/ssa/rewritedec.go
@@ -8,31 +8,31 @@
func rewriteValuedec(v *Value) bool {
switch v.Op {
case OpComplexImag:
- return rewriteValuedec_OpComplexImag_0(v)
+ return rewriteValuedec_OpComplexImag(v)
case OpComplexReal:
- return rewriteValuedec_OpComplexReal_0(v)
+ return rewriteValuedec_OpComplexReal(v)
case OpIData:
- return rewriteValuedec_OpIData_0(v)
+ return rewriteValuedec_OpIData(v)
case OpITab:
- return rewriteValuedec_OpITab_0(v)
+ return rewriteValuedec_OpITab(v)
case OpLoad:
- return rewriteValuedec_OpLoad_0(v)
+ return rewriteValuedec_OpLoad(v)
case OpSliceCap:
- return rewriteValuedec_OpSliceCap_0(v)
+ return rewriteValuedec_OpSliceCap(v)
case OpSliceLen:
- return rewriteValuedec_OpSliceLen_0(v)
+ return rewriteValuedec_OpSliceLen(v)
case OpSlicePtr:
- return rewriteValuedec_OpSlicePtr_0(v)
+ return rewriteValuedec_OpSlicePtr(v)
case OpStore:
- return rewriteValuedec_OpStore_0(v)
+ return rewriteValuedec_OpStore(v)
case OpStringLen:
- return rewriteValuedec_OpStringLen_0(v)
+ return rewriteValuedec_OpStringLen(v)
case OpStringPtr:
- return rewriteValuedec_OpStringPtr_0(v)
+ return rewriteValuedec_OpStringPtr(v)
}
return false
}
-func rewriteValuedec_OpComplexImag_0(v *Value) bool {
+func rewriteValuedec_OpComplexImag(v *Value) bool {
v_0 := v.Args[0]
// match: (ComplexImag (ComplexMake _ imag ))
// result: imag
@@ -48,7 +48,7 @@
}
return false
}
-func rewriteValuedec_OpComplexReal_0(v *Value) bool {
+func rewriteValuedec_OpComplexReal(v *Value) bool {
v_0 := v.Args[0]
// match: (ComplexReal (ComplexMake real _ ))
// result: real
@@ -65,7 +65,7 @@
}
return false
}
-func rewriteValuedec_OpIData_0(v *Value) bool {
+func rewriteValuedec_OpIData(v *Value) bool {
v_0 := v.Args[0]
// match: (IData (IMake _ data))
// result: data
@@ -81,7 +81,7 @@
}
return false
}
-func rewriteValuedec_OpITab_0(v *Value) bool {
+func rewriteValuedec_OpITab(v *Value) bool {
v_0 := v.Args[0]
// match: (ITab (IMake itab _))
// result: itab
@@ -98,7 +98,7 @@
}
return false
}
-func rewriteValuedec_OpLoad_0(v *Value) bool {
+func rewriteValuedec_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -233,7 +233,7 @@
}
return false
}
-func rewriteValuedec_OpSliceCap_0(v *Value) bool {
+func rewriteValuedec_OpSliceCap(v *Value) bool {
v_0 := v.Args[0]
// match: (SliceCap (SliceMake _ _ cap))
// result: cap
@@ -249,7 +249,7 @@
}
return false
}
-func rewriteValuedec_OpSliceLen_0(v *Value) bool {
+func rewriteValuedec_OpSliceLen(v *Value) bool {
v_0 := v.Args[0]
// match: (SliceLen (SliceMake _ len _))
// result: len
@@ -266,7 +266,7 @@
}
return false
}
-func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
+func rewriteValuedec_OpSlicePtr(v *Value) bool {
v_0 := v.Args[0]
// match: (SlicePtr (SliceMake ptr _ _ ))
// result: ptr
@@ -283,7 +283,7 @@
}
return false
}
-func rewriteValuedec_OpStore_0(v *Value) bool {
+func rewriteValuedec_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -436,7 +436,7 @@
}
return false
}
-func rewriteValuedec_OpStringLen_0(v *Value) bool {
+func rewriteValuedec_OpStringLen(v *Value) bool {
v_0 := v.Args[0]
// match: (StringLen (StringMake _ len))
// result: len
@@ -452,7 +452,7 @@
}
return false
}
-func rewriteValuedec_OpStringPtr_0(v *Value) bool {
+func rewriteValuedec_OpStringPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (StringPtr (StringMake ptr _))
// result: ptr
diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go
index 28b3ab7..f518ffc 100644
--- a/src/cmd/compile/internal/ssa/rewritedec64.go
+++ b/src/cmd/compile/internal/ssa/rewritedec64.go
@@ -8,125 +8,125 @@
func rewriteValuedec64(v *Value) bool {
switch v.Op {
case OpAdd64:
- return rewriteValuedec64_OpAdd64_0(v)
+ return rewriteValuedec64_OpAdd64(v)
case OpAnd64:
- return rewriteValuedec64_OpAnd64_0(v)
+ return rewriteValuedec64_OpAnd64(v)
case OpArg:
- return rewriteValuedec64_OpArg_0(v)
+ return rewriteValuedec64_OpArg(v)
case OpBitLen64:
- return rewriteValuedec64_OpBitLen64_0(v)
+ return rewriteValuedec64_OpBitLen64(v)
case OpBswap64:
- return rewriteValuedec64_OpBswap64_0(v)
+ return rewriteValuedec64_OpBswap64(v)
case OpCom64:
- return rewriteValuedec64_OpCom64_0(v)
+ return rewriteValuedec64_OpCom64(v)
case OpConst64:
- return rewriteValuedec64_OpConst64_0(v)
+ return rewriteValuedec64_OpConst64(v)
case OpCtz64:
- return rewriteValuedec64_OpCtz64_0(v)
+ return rewriteValuedec64_OpCtz64(v)
case OpCtz64NonZero:
- return rewriteValuedec64_OpCtz64NonZero_0(v)
+ return rewriteValuedec64_OpCtz64NonZero(v)
case OpEq64:
- return rewriteValuedec64_OpEq64_0(v)
+ return rewriteValuedec64_OpEq64(v)
case OpGeq64:
- return rewriteValuedec64_OpGeq64_0(v)
+ return rewriteValuedec64_OpGeq64(v)
case OpGeq64U:
- return rewriteValuedec64_OpGeq64U_0(v)
+ return rewriteValuedec64_OpGeq64U(v)
case OpGreater64:
- return rewriteValuedec64_OpGreater64_0(v)
+ return rewriteValuedec64_OpGreater64(v)
case OpGreater64U:
- return rewriteValuedec64_OpGreater64U_0(v)
+ return rewriteValuedec64_OpGreater64U(v)
case OpInt64Hi:
- return rewriteValuedec64_OpInt64Hi_0(v)
+ return rewriteValuedec64_OpInt64Hi(v)
case OpInt64Lo:
- return rewriteValuedec64_OpInt64Lo_0(v)
+ return rewriteValuedec64_OpInt64Lo(v)
case OpLeq64:
- return rewriteValuedec64_OpLeq64_0(v)
+ return rewriteValuedec64_OpLeq64(v)
case OpLeq64U:
- return rewriteValuedec64_OpLeq64U_0(v)
+ return rewriteValuedec64_OpLeq64U(v)
case OpLess64:
- return rewriteValuedec64_OpLess64_0(v)
+ return rewriteValuedec64_OpLess64(v)
case OpLess64U:
- return rewriteValuedec64_OpLess64U_0(v)
+ return rewriteValuedec64_OpLess64U(v)
case OpLoad:
- return rewriteValuedec64_OpLoad_0(v)
+ return rewriteValuedec64_OpLoad(v)
case OpLsh16x64:
- return rewriteValuedec64_OpLsh16x64_0(v)
+ return rewriteValuedec64_OpLsh16x64(v)
case OpLsh32x64:
- return rewriteValuedec64_OpLsh32x64_0(v)
+ return rewriteValuedec64_OpLsh32x64(v)
case OpLsh64x16:
- return rewriteValuedec64_OpLsh64x16_0(v)
+ return rewriteValuedec64_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValuedec64_OpLsh64x32_0(v)
+ return rewriteValuedec64_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValuedec64_OpLsh64x64_0(v)
+ return rewriteValuedec64_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValuedec64_OpLsh64x8_0(v)
+ return rewriteValuedec64_OpLsh64x8(v)
case OpLsh8x64:
- return rewriteValuedec64_OpLsh8x64_0(v)
+ return rewriteValuedec64_OpLsh8x64(v)
case OpMul64:
- return rewriteValuedec64_OpMul64_0(v)
+ return rewriteValuedec64_OpMul64(v)
case OpNeg64:
- return rewriteValuedec64_OpNeg64_0(v)
+ return rewriteValuedec64_OpNeg64(v)
case OpNeq64:
- return rewriteValuedec64_OpNeq64_0(v)
+ return rewriteValuedec64_OpNeq64(v)
case OpOr64:
- return rewriteValuedec64_OpOr64_0(v)
+ return rewriteValuedec64_OpOr64(v)
case OpRsh16Ux64:
- return rewriteValuedec64_OpRsh16Ux64_0(v)
+ return rewriteValuedec64_OpRsh16Ux64(v)
case OpRsh16x64:
- return rewriteValuedec64_OpRsh16x64_0(v)
+ return rewriteValuedec64_OpRsh16x64(v)
case OpRsh32Ux64:
- return rewriteValuedec64_OpRsh32Ux64_0(v)
+ return rewriteValuedec64_OpRsh32Ux64(v)
case OpRsh32x64:
- return rewriteValuedec64_OpRsh32x64_0(v)
+ return rewriteValuedec64_OpRsh32x64(v)
case OpRsh64Ux16:
- return rewriteValuedec64_OpRsh64Ux16_0(v)
+ return rewriteValuedec64_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValuedec64_OpRsh64Ux32_0(v)
+ return rewriteValuedec64_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValuedec64_OpRsh64Ux64_0(v)
+ return rewriteValuedec64_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValuedec64_OpRsh64Ux8_0(v)
+ return rewriteValuedec64_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValuedec64_OpRsh64x16_0(v)
+ return rewriteValuedec64_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValuedec64_OpRsh64x32_0(v)
+ return rewriteValuedec64_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValuedec64_OpRsh64x64_0(v)
+ return rewriteValuedec64_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValuedec64_OpRsh64x8_0(v)
+ return rewriteValuedec64_OpRsh64x8(v)
case OpRsh8Ux64:
- return rewriteValuedec64_OpRsh8Ux64_0(v)
+ return rewriteValuedec64_OpRsh8Ux64(v)
case OpRsh8x64:
- return rewriteValuedec64_OpRsh8x64_0(v)
+ return rewriteValuedec64_OpRsh8x64(v)
case OpSignExt16to64:
- return rewriteValuedec64_OpSignExt16to64_0(v)
+ return rewriteValuedec64_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValuedec64_OpSignExt32to64_0(v)
+ return rewriteValuedec64_OpSignExt32to64(v)
case OpSignExt8to64:
- return rewriteValuedec64_OpSignExt8to64_0(v)
+ return rewriteValuedec64_OpSignExt8to64(v)
case OpStore:
- return rewriteValuedec64_OpStore_0(v)
+ return rewriteValuedec64_OpStore(v)
case OpSub64:
- return rewriteValuedec64_OpSub64_0(v)
+ return rewriteValuedec64_OpSub64(v)
case OpTrunc64to16:
- return rewriteValuedec64_OpTrunc64to16_0(v)
+ return rewriteValuedec64_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValuedec64_OpTrunc64to32_0(v)
+ return rewriteValuedec64_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValuedec64_OpTrunc64to8_0(v)
+ return rewriteValuedec64_OpTrunc64to8(v)
case OpXor64:
- return rewriteValuedec64_OpXor64_0(v)
+ return rewriteValuedec64_OpXor64(v)
case OpZeroExt16to64:
- return rewriteValuedec64_OpZeroExt16to64_0(v)
+ return rewriteValuedec64_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValuedec64_OpZeroExt32to64_0(v)
+ return rewriteValuedec64_OpZeroExt32to64(v)
case OpZeroExt8to64:
- return rewriteValuedec64_OpZeroExt8to64_0(v)
+ return rewriteValuedec64_OpZeroExt8to64(v)
}
return false
}
-func rewriteValuedec64_OpAdd64_0(v *Value) bool {
+func rewriteValuedec64_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -168,7 +168,7 @@
return true
}
}
-func rewriteValuedec64_OpAnd64_0(v *Value) bool {
+func rewriteValuedec64_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -198,7 +198,7 @@
return true
}
}
-func rewriteValuedec64_OpArg_0(v *Value) bool {
+func rewriteValuedec64_OpArg(v *Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -284,7 +284,7 @@
}
return false
}
-func rewriteValuedec64_OpBitLen64_0(v *Value) bool {
+func rewriteValuedec64_OpBitLen64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -314,7 +314,7 @@
return true
}
}
-func rewriteValuedec64_OpBswap64_0(v *Value) bool {
+func rewriteValuedec64_OpBswap64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -336,7 +336,7 @@
return true
}
}
-func rewriteValuedec64_OpCom64_0(v *Value) bool {
+func rewriteValuedec64_OpCom64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -358,7 +358,7 @@
return true
}
}
-func rewriteValuedec64_OpConst64_0(v *Value) bool {
+func rewriteValuedec64_OpConst64(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (Const64 <t> [c])
@@ -399,7 +399,7 @@
}
return false
}
-func rewriteValuedec64_OpCtz64_0(v *Value) bool {
+func rewriteValuedec64_OpCtz64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -431,7 +431,7 @@
return true
}
}
-func rewriteValuedec64_OpCtz64NonZero_0(v *Value) bool {
+func rewriteValuedec64_OpCtz64NonZero(v *Value) bool {
v_0 := v.Args[0]
// match: (Ctz64NonZero x)
// result: (Ctz64 x)
@@ -442,7 +442,7 @@
return true
}
}
-func rewriteValuedec64_OpEq64_0(v *Value) bool {
+func rewriteValuedec64_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -472,7 +472,7 @@
return true
}
}
-func rewriteValuedec64_OpGeq64_0(v *Value) bool {
+func rewriteValuedec64_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -512,7 +512,7 @@
return true
}
}
-func rewriteValuedec64_OpGeq64U_0(v *Value) bool {
+func rewriteValuedec64_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -552,7 +552,7 @@
return true
}
}
-func rewriteValuedec64_OpGreater64_0(v *Value) bool {
+func rewriteValuedec64_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -592,7 +592,7 @@
return true
}
}
-func rewriteValuedec64_OpGreater64U_0(v *Value) bool {
+func rewriteValuedec64_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -632,7 +632,7 @@
return true
}
}
-func rewriteValuedec64_OpInt64Hi_0(v *Value) bool {
+func rewriteValuedec64_OpInt64Hi(v *Value) bool {
v_0 := v.Args[0]
// match: (Int64Hi (Int64Make hi _))
// result: hi
@@ -649,7 +649,7 @@
}
return false
}
-func rewriteValuedec64_OpInt64Lo_0(v *Value) bool {
+func rewriteValuedec64_OpInt64Lo(v *Value) bool {
v_0 := v.Args[0]
// match: (Int64Lo (Int64Make _ lo))
// result: lo
@@ -665,7 +665,7 @@
}
return false
}
-func rewriteValuedec64_OpLeq64_0(v *Value) bool {
+func rewriteValuedec64_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -705,7 +705,7 @@
return true
}
}
-func rewriteValuedec64_OpLeq64U_0(v *Value) bool {
+func rewriteValuedec64_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -745,7 +745,7 @@
return true
}
}
-func rewriteValuedec64_OpLess64_0(v *Value) bool {
+func rewriteValuedec64_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -785,7 +785,7 @@
return true
}
}
-func rewriteValuedec64_OpLess64U_0(v *Value) bool {
+func rewriteValuedec64_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -825,7 +825,7 @@
return true
}
}
-func rewriteValuedec64_OpLoad_0(v *Value) bool {
+func rewriteValuedec64_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -929,7 +929,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh16x64_0(v *Value) bool {
+func rewriteValuedec64_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -996,7 +996,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh32x64_0(v *Value) bool {
+func rewriteValuedec64_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1063,7 +1063,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh64x16_0(v *Value) bool {
+func rewriteValuedec64_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1112,7 +1112,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh64x32_0(v *Value) bool {
+func rewriteValuedec64_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1161,7 +1161,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh64x64_0(v *Value) bool {
+func rewriteValuedec64_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1228,7 +1228,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh64x8_0(v *Value) bool {
+func rewriteValuedec64_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1277,7 +1277,7 @@
}
return false
}
-func rewriteValuedec64_OpLsh8x64_0(v *Value) bool {
+func rewriteValuedec64_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1344,7 +1344,7 @@
}
return false
}
-func rewriteValuedec64_OpMul64_0(v *Value) bool {
+func rewriteValuedec64_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1398,7 +1398,7 @@
return true
}
}
-func rewriteValuedec64_OpNeg64_0(v *Value) bool {
+func rewriteValuedec64_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg64 <t> x)
@@ -1414,7 +1414,7 @@
return true
}
}
-func rewriteValuedec64_OpNeq64_0(v *Value) bool {
+func rewriteValuedec64_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1444,7 +1444,7 @@
return true
}
}
-func rewriteValuedec64_OpOr64_0(v *Value) bool {
+func rewriteValuedec64_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1474,7 +1474,7 @@
return true
}
}
-func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1541,7 +1541,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh16x64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1611,7 +1611,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1678,7 +1678,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh32x64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1746,7 +1746,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1795,7 +1795,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1844,7 +1844,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1911,7 +1911,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1960,7 +1960,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64x16_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2021,7 +2021,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64x32_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2080,7 +2080,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64x64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2157,7 +2157,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh64x8_0(v *Value) bool {
+func rewriteValuedec64_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2218,7 +2218,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2285,7 +2285,7 @@
}
return false
}
-func rewriteValuedec64_OpRsh8x64_0(v *Value) bool {
+func rewriteValuedec64_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2355,7 +2355,7 @@
}
return false
}
-func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool {
+func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2370,7 +2370,7 @@
return true
}
}
-func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool {
+func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2386,7 +2386,7 @@
return true
}
}
-func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool {
+func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2401,7 +2401,7 @@
return true
}
}
-func rewriteValuedec64_OpStore_0(v *Value) bool {
+func rewriteValuedec64_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
@@ -2469,7 +2469,7 @@
}
return false
}
-func rewriteValuedec64_OpSub64_0(v *Value) bool {
+func rewriteValuedec64_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2511,7 +2511,7 @@
return true
}
}
-func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 (Int64Make _ lo))
// result: (Trunc32to16 lo)
@@ -2526,7 +2526,7 @@
}
return false
}
-func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 (Int64Make _ lo))
// result: lo
@@ -2542,7 +2542,7 @@
}
return false
}
-func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 (Int64Make _ lo))
// result: (Trunc32to8 lo)
@@ -2557,7 +2557,7 @@
}
return false
}
-func rewriteValuedec64_OpXor64_0(v *Value) bool {
+func rewriteValuedec64_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2587,7 +2587,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2602,7 +2602,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
@@ -2618,7 +2618,7 @@
return true
}
}
-func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
typ := &b.Func.Config.Types
diff --git a/src/cmd/compile/internal/ssa/rewritedecArgs.go b/src/cmd/compile/internal/ssa/rewritedecArgs.go
index 0f6d01f..9a9e522 100644
--- a/src/cmd/compile/internal/ssa/rewritedecArgs.go
+++ b/src/cmd/compile/internal/ssa/rewritedecArgs.go
@@ -6,11 +6,11 @@
func rewriteValuedecArgs(v *Value) bool {
switch v.Op {
case OpArg:
- return rewriteValuedecArgs_OpArg_0(v) || rewriteValuedecArgs_OpArg_10(v)
+ return rewriteValuedecArgs_OpArg(v)
}
return false
}
-func rewriteValuedecArgs_OpArg_0(v *Value) bool {
+func rewriteValuedecArgs_OpArg(v *Value) bool {
b := v.Block
config := b.Func.Config
fe := b.Func.fe
@@ -222,11 +222,6 @@
v.AddArg(v3)
return true
}
- return false
-}
-func rewriteValuedecArgs_OpArg_10(v *Value) bool {
- b := v.Block
- fe := b.Func.fe
// match: (Arg <t>)
// cond: t.IsArray() && t.NumElem() == 0
// result: (ArrayMake0)
diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go
index ea0d92c..9d88652 100644
--- a/src/cmd/compile/internal/ssa/rewritegeneric.go
+++ b/src/cmd/compile/internal/ssa/rewritegeneric.go
@@ -9,471 +9,471 @@
func rewriteValuegeneric(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValuegeneric_OpAdd16_0(v)
+ return rewriteValuegeneric_OpAdd16(v)
case OpAdd32:
- return rewriteValuegeneric_OpAdd32_0(v)
+ return rewriteValuegeneric_OpAdd32(v)
case OpAdd32F:
- return rewriteValuegeneric_OpAdd32F_0(v)
+ return rewriteValuegeneric_OpAdd32F(v)
case OpAdd64:
- return rewriteValuegeneric_OpAdd64_0(v)
+ return rewriteValuegeneric_OpAdd64(v)
case OpAdd64F:
- return rewriteValuegeneric_OpAdd64F_0(v)
+ return rewriteValuegeneric_OpAdd64F(v)
case OpAdd8:
- return rewriteValuegeneric_OpAdd8_0(v)
+ return rewriteValuegeneric_OpAdd8(v)
case OpAddPtr:
- return rewriteValuegeneric_OpAddPtr_0(v)
+ return rewriteValuegeneric_OpAddPtr(v)
case OpAnd16:
- return rewriteValuegeneric_OpAnd16_0(v)
+ return rewriteValuegeneric_OpAnd16(v)
case OpAnd32:
- return rewriteValuegeneric_OpAnd32_0(v)
+ return rewriteValuegeneric_OpAnd32(v)
case OpAnd64:
- return rewriteValuegeneric_OpAnd64_0(v)
+ return rewriteValuegeneric_OpAnd64(v)
case OpAnd8:
- return rewriteValuegeneric_OpAnd8_0(v)
+ return rewriteValuegeneric_OpAnd8(v)
case OpArraySelect:
- return rewriteValuegeneric_OpArraySelect_0(v)
+ return rewriteValuegeneric_OpArraySelect(v)
case OpCom16:
- return rewriteValuegeneric_OpCom16_0(v)
+ return rewriteValuegeneric_OpCom16(v)
case OpCom32:
- return rewriteValuegeneric_OpCom32_0(v)
+ return rewriteValuegeneric_OpCom32(v)
case OpCom64:
- return rewriteValuegeneric_OpCom64_0(v)
+ return rewriteValuegeneric_OpCom64(v)
case OpCom8:
- return rewriteValuegeneric_OpCom8_0(v)
+ return rewriteValuegeneric_OpCom8(v)
case OpConstInterface:
- return rewriteValuegeneric_OpConstInterface_0(v)
+ return rewriteValuegeneric_OpConstInterface(v)
case OpConstSlice:
- return rewriteValuegeneric_OpConstSlice_0(v)
+ return rewriteValuegeneric_OpConstSlice(v)
case OpConstString:
- return rewriteValuegeneric_OpConstString_0(v)
+ return rewriteValuegeneric_OpConstString(v)
case OpConvert:
- return rewriteValuegeneric_OpConvert_0(v)
+ return rewriteValuegeneric_OpConvert(v)
case OpCvt32Fto32:
- return rewriteValuegeneric_OpCvt32Fto32_0(v)
+ return rewriteValuegeneric_OpCvt32Fto32(v)
case OpCvt32Fto64:
- return rewriteValuegeneric_OpCvt32Fto64_0(v)
+ return rewriteValuegeneric_OpCvt32Fto64(v)
case OpCvt32Fto64F:
- return rewriteValuegeneric_OpCvt32Fto64F_0(v)
+ return rewriteValuegeneric_OpCvt32Fto64F(v)
case OpCvt32to32F:
- return rewriteValuegeneric_OpCvt32to32F_0(v)
+ return rewriteValuegeneric_OpCvt32to32F(v)
case OpCvt32to64F:
- return rewriteValuegeneric_OpCvt32to64F_0(v)
+ return rewriteValuegeneric_OpCvt32to64F(v)
case OpCvt64Fto32:
- return rewriteValuegeneric_OpCvt64Fto32_0(v)
+ return rewriteValuegeneric_OpCvt64Fto32(v)
case OpCvt64Fto32F:
- return rewriteValuegeneric_OpCvt64Fto32F_0(v)
+ return rewriteValuegeneric_OpCvt64Fto32F(v)
case OpCvt64Fto64:
- return rewriteValuegeneric_OpCvt64Fto64_0(v)
+ return rewriteValuegeneric_OpCvt64Fto64(v)
case OpCvt64to32F:
- return rewriteValuegeneric_OpCvt64to32F_0(v)
+ return rewriteValuegeneric_OpCvt64to32F(v)
case OpCvt64to64F:
- return rewriteValuegeneric_OpCvt64to64F_0(v)
+ return rewriteValuegeneric_OpCvt64to64F(v)
case OpDiv16:
- return rewriteValuegeneric_OpDiv16_0(v)
+ return rewriteValuegeneric_OpDiv16(v)
case OpDiv16u:
- return rewriteValuegeneric_OpDiv16u_0(v)
+ return rewriteValuegeneric_OpDiv16u(v)
case OpDiv32:
- return rewriteValuegeneric_OpDiv32_0(v)
+ return rewriteValuegeneric_OpDiv32(v)
case OpDiv32F:
- return rewriteValuegeneric_OpDiv32F_0(v)
+ return rewriteValuegeneric_OpDiv32F(v)
case OpDiv32u:
- return rewriteValuegeneric_OpDiv32u_0(v)
+ return rewriteValuegeneric_OpDiv32u(v)
case OpDiv64:
- return rewriteValuegeneric_OpDiv64_0(v)
+ return rewriteValuegeneric_OpDiv64(v)
case OpDiv64F:
- return rewriteValuegeneric_OpDiv64F_0(v)
+ return rewriteValuegeneric_OpDiv64F(v)
case OpDiv64u:
- return rewriteValuegeneric_OpDiv64u_0(v)
+ return rewriteValuegeneric_OpDiv64u(v)
case OpDiv8:
- return rewriteValuegeneric_OpDiv8_0(v)
+ return rewriteValuegeneric_OpDiv8(v)
case OpDiv8u:
- return rewriteValuegeneric_OpDiv8u_0(v)
+ return rewriteValuegeneric_OpDiv8u(v)
case OpEq16:
- return rewriteValuegeneric_OpEq16_0(v) || rewriteValuegeneric_OpEq16_10(v)
+ return rewriteValuegeneric_OpEq16(v)
case OpEq32:
- return rewriteValuegeneric_OpEq32_0(v) || rewriteValuegeneric_OpEq32_10(v)
+ return rewriteValuegeneric_OpEq32(v)
case OpEq32F:
- return rewriteValuegeneric_OpEq32F_0(v)
+ return rewriteValuegeneric_OpEq32F(v)
case OpEq64:
- return rewriteValuegeneric_OpEq64_0(v) || rewriteValuegeneric_OpEq64_10(v)
+ return rewriteValuegeneric_OpEq64(v)
case OpEq64F:
- return rewriteValuegeneric_OpEq64F_0(v)
+ return rewriteValuegeneric_OpEq64F(v)
case OpEq8:
- return rewriteValuegeneric_OpEq8_0(v)
+ return rewriteValuegeneric_OpEq8(v)
case OpEqB:
- return rewriteValuegeneric_OpEqB_0(v)
+ return rewriteValuegeneric_OpEqB(v)
case OpEqInter:
- return rewriteValuegeneric_OpEqInter_0(v)
+ return rewriteValuegeneric_OpEqInter(v)
case OpEqPtr:
- return rewriteValuegeneric_OpEqPtr_0(v) || rewriteValuegeneric_OpEqPtr_10(v)
+ return rewriteValuegeneric_OpEqPtr(v)
case OpEqSlice:
- return rewriteValuegeneric_OpEqSlice_0(v)
+ return rewriteValuegeneric_OpEqSlice(v)
case OpGeq16:
- return rewriteValuegeneric_OpGeq16_0(v)
+ return rewriteValuegeneric_OpGeq16(v)
case OpGeq16U:
- return rewriteValuegeneric_OpGeq16U_0(v)
+ return rewriteValuegeneric_OpGeq16U(v)
case OpGeq32:
- return rewriteValuegeneric_OpGeq32_0(v)
+ return rewriteValuegeneric_OpGeq32(v)
case OpGeq32F:
- return rewriteValuegeneric_OpGeq32F_0(v)
+ return rewriteValuegeneric_OpGeq32F(v)
case OpGeq32U:
- return rewriteValuegeneric_OpGeq32U_0(v)
+ return rewriteValuegeneric_OpGeq32U(v)
case OpGeq64:
- return rewriteValuegeneric_OpGeq64_0(v)
+ return rewriteValuegeneric_OpGeq64(v)
case OpGeq64F:
- return rewriteValuegeneric_OpGeq64F_0(v)
+ return rewriteValuegeneric_OpGeq64F(v)
case OpGeq64U:
- return rewriteValuegeneric_OpGeq64U_0(v)
+ return rewriteValuegeneric_OpGeq64U(v)
case OpGeq8:
- return rewriteValuegeneric_OpGeq8_0(v)
+ return rewriteValuegeneric_OpGeq8(v)
case OpGeq8U:
- return rewriteValuegeneric_OpGeq8U_0(v)
+ return rewriteValuegeneric_OpGeq8U(v)
case OpGreater16:
- return rewriteValuegeneric_OpGreater16_0(v)
+ return rewriteValuegeneric_OpGreater16(v)
case OpGreater16U:
- return rewriteValuegeneric_OpGreater16U_0(v)
+ return rewriteValuegeneric_OpGreater16U(v)
case OpGreater32:
- return rewriteValuegeneric_OpGreater32_0(v)
+ return rewriteValuegeneric_OpGreater32(v)
case OpGreater32F:
- return rewriteValuegeneric_OpGreater32F_0(v)
+ return rewriteValuegeneric_OpGreater32F(v)
case OpGreater32U:
- return rewriteValuegeneric_OpGreater32U_0(v)
+ return rewriteValuegeneric_OpGreater32U(v)
case OpGreater64:
- return rewriteValuegeneric_OpGreater64_0(v)
+ return rewriteValuegeneric_OpGreater64(v)
case OpGreater64F:
- return rewriteValuegeneric_OpGreater64F_0(v)
+ return rewriteValuegeneric_OpGreater64F(v)
case OpGreater64U:
- return rewriteValuegeneric_OpGreater64U_0(v)
+ return rewriteValuegeneric_OpGreater64U(v)
case OpGreater8:
- return rewriteValuegeneric_OpGreater8_0(v)
+ return rewriteValuegeneric_OpGreater8(v)
case OpGreater8U:
- return rewriteValuegeneric_OpGreater8U_0(v)
+ return rewriteValuegeneric_OpGreater8U(v)
case OpIMake:
- return rewriteValuegeneric_OpIMake_0(v)
+ return rewriteValuegeneric_OpIMake(v)
case OpInterCall:
- return rewriteValuegeneric_OpInterCall_0(v)
+ return rewriteValuegeneric_OpInterCall(v)
case OpIsInBounds:
- return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v)
+ return rewriteValuegeneric_OpIsInBounds(v)
case OpIsNonNil:
- return rewriteValuegeneric_OpIsNonNil_0(v)
+ return rewriteValuegeneric_OpIsNonNil(v)
case OpIsSliceInBounds:
- return rewriteValuegeneric_OpIsSliceInBounds_0(v)
+ return rewriteValuegeneric_OpIsSliceInBounds(v)
case OpLeq16:
- return rewriteValuegeneric_OpLeq16_0(v)
+ return rewriteValuegeneric_OpLeq16(v)
case OpLeq16U:
- return rewriteValuegeneric_OpLeq16U_0(v)
+ return rewriteValuegeneric_OpLeq16U(v)
case OpLeq32:
- return rewriteValuegeneric_OpLeq32_0(v)
+ return rewriteValuegeneric_OpLeq32(v)
case OpLeq32F:
- return rewriteValuegeneric_OpLeq32F_0(v)
+ return rewriteValuegeneric_OpLeq32F(v)
case OpLeq32U:
- return rewriteValuegeneric_OpLeq32U_0(v)
+ return rewriteValuegeneric_OpLeq32U(v)
case OpLeq64:
- return rewriteValuegeneric_OpLeq64_0(v)
+ return rewriteValuegeneric_OpLeq64(v)
case OpLeq64F:
- return rewriteValuegeneric_OpLeq64F_0(v)
+ return rewriteValuegeneric_OpLeq64F(v)
case OpLeq64U:
- return rewriteValuegeneric_OpLeq64U_0(v)
+ return rewriteValuegeneric_OpLeq64U(v)
case OpLeq8:
- return rewriteValuegeneric_OpLeq8_0(v)
+ return rewriteValuegeneric_OpLeq8(v)
case OpLeq8U:
- return rewriteValuegeneric_OpLeq8U_0(v)
+ return rewriteValuegeneric_OpLeq8U(v)
case OpLess16:
- return rewriteValuegeneric_OpLess16_0(v)
+ return rewriteValuegeneric_OpLess16(v)
case OpLess16U:
- return rewriteValuegeneric_OpLess16U_0(v)
+ return rewriteValuegeneric_OpLess16U(v)
case OpLess32:
- return rewriteValuegeneric_OpLess32_0(v)
+ return rewriteValuegeneric_OpLess32(v)
case OpLess32F:
- return rewriteValuegeneric_OpLess32F_0(v)
+ return rewriteValuegeneric_OpLess32F(v)
case OpLess32U:
- return rewriteValuegeneric_OpLess32U_0(v)
+ return rewriteValuegeneric_OpLess32U(v)
case OpLess64:
- return rewriteValuegeneric_OpLess64_0(v)
+ return rewriteValuegeneric_OpLess64(v)
case OpLess64F:
- return rewriteValuegeneric_OpLess64F_0(v)
+ return rewriteValuegeneric_OpLess64F(v)
case OpLess64U:
- return rewriteValuegeneric_OpLess64U_0(v)
+ return rewriteValuegeneric_OpLess64U(v)
case OpLess8:
- return rewriteValuegeneric_OpLess8_0(v)
+ return rewriteValuegeneric_OpLess8(v)
case OpLess8U:
- return rewriteValuegeneric_OpLess8U_0(v)
+ return rewriteValuegeneric_OpLess8U(v)
case OpLoad:
- return rewriteValuegeneric_OpLoad_0(v) || rewriteValuegeneric_OpLoad_10(v) || rewriteValuegeneric_OpLoad_20(v)
+ return rewriteValuegeneric_OpLoad(v)
case OpLsh16x16:
- return rewriteValuegeneric_OpLsh16x16_0(v)
+ return rewriteValuegeneric_OpLsh16x16(v)
case OpLsh16x32:
- return rewriteValuegeneric_OpLsh16x32_0(v)
+ return rewriteValuegeneric_OpLsh16x32(v)
case OpLsh16x64:
- return rewriteValuegeneric_OpLsh16x64_0(v)
+ return rewriteValuegeneric_OpLsh16x64(v)
case OpLsh16x8:
- return rewriteValuegeneric_OpLsh16x8_0(v)
+ return rewriteValuegeneric_OpLsh16x8(v)
case OpLsh32x16:
- return rewriteValuegeneric_OpLsh32x16_0(v)
+ return rewriteValuegeneric_OpLsh32x16(v)
case OpLsh32x32:
- return rewriteValuegeneric_OpLsh32x32_0(v)
+ return rewriteValuegeneric_OpLsh32x32(v)
case OpLsh32x64:
- return rewriteValuegeneric_OpLsh32x64_0(v)
+ return rewriteValuegeneric_OpLsh32x64(v)
case OpLsh32x8:
- return rewriteValuegeneric_OpLsh32x8_0(v)
+ return rewriteValuegeneric_OpLsh32x8(v)
case OpLsh64x16:
- return rewriteValuegeneric_OpLsh64x16_0(v)
+ return rewriteValuegeneric_OpLsh64x16(v)
case OpLsh64x32:
- return rewriteValuegeneric_OpLsh64x32_0(v)
+ return rewriteValuegeneric_OpLsh64x32(v)
case OpLsh64x64:
- return rewriteValuegeneric_OpLsh64x64_0(v)
+ return rewriteValuegeneric_OpLsh64x64(v)
case OpLsh64x8:
- return rewriteValuegeneric_OpLsh64x8_0(v)
+ return rewriteValuegeneric_OpLsh64x8(v)
case OpLsh8x16:
- return rewriteValuegeneric_OpLsh8x16_0(v)
+ return rewriteValuegeneric_OpLsh8x16(v)
case OpLsh8x32:
- return rewriteValuegeneric_OpLsh8x32_0(v)
+ return rewriteValuegeneric_OpLsh8x32(v)
case OpLsh8x64:
- return rewriteValuegeneric_OpLsh8x64_0(v)
+ return rewriteValuegeneric_OpLsh8x64(v)
case OpLsh8x8:
- return rewriteValuegeneric_OpLsh8x8_0(v)
+ return rewriteValuegeneric_OpLsh8x8(v)
case OpMod16:
- return rewriteValuegeneric_OpMod16_0(v)
+ return rewriteValuegeneric_OpMod16(v)
case OpMod16u:
- return rewriteValuegeneric_OpMod16u_0(v)
+ return rewriteValuegeneric_OpMod16u(v)
case OpMod32:
- return rewriteValuegeneric_OpMod32_0(v)
+ return rewriteValuegeneric_OpMod32(v)
case OpMod32u:
- return rewriteValuegeneric_OpMod32u_0(v)
+ return rewriteValuegeneric_OpMod32u(v)
case OpMod64:
- return rewriteValuegeneric_OpMod64_0(v)
+ return rewriteValuegeneric_OpMod64(v)
case OpMod64u:
- return rewriteValuegeneric_OpMod64u_0(v)
+ return rewriteValuegeneric_OpMod64u(v)
case OpMod8:
- return rewriteValuegeneric_OpMod8_0(v)
+ return rewriteValuegeneric_OpMod8(v)
case OpMod8u:
- return rewriteValuegeneric_OpMod8u_0(v)
+ return rewriteValuegeneric_OpMod8u(v)
case OpMove:
- return rewriteValuegeneric_OpMove_0(v) || rewriteValuegeneric_OpMove_10(v) || rewriteValuegeneric_OpMove_20(v)
+ return rewriteValuegeneric_OpMove(v)
case OpMul16:
- return rewriteValuegeneric_OpMul16_0(v)
+ return rewriteValuegeneric_OpMul16(v)
case OpMul32:
- return rewriteValuegeneric_OpMul32_0(v)
+ return rewriteValuegeneric_OpMul32(v)
case OpMul32F:
- return rewriteValuegeneric_OpMul32F_0(v)
+ return rewriteValuegeneric_OpMul32F(v)
case OpMul64:
- return rewriteValuegeneric_OpMul64_0(v)
+ return rewriteValuegeneric_OpMul64(v)
case OpMul64F:
- return rewriteValuegeneric_OpMul64F_0(v)
+ return rewriteValuegeneric_OpMul64F(v)
case OpMul8:
- return rewriteValuegeneric_OpMul8_0(v)
+ return rewriteValuegeneric_OpMul8(v)
case OpNeg16:
- return rewriteValuegeneric_OpNeg16_0(v)
+ return rewriteValuegeneric_OpNeg16(v)
case OpNeg32:
- return rewriteValuegeneric_OpNeg32_0(v)
+ return rewriteValuegeneric_OpNeg32(v)
case OpNeg32F:
- return rewriteValuegeneric_OpNeg32F_0(v)
+ return rewriteValuegeneric_OpNeg32F(v)
case OpNeg64:
- return rewriteValuegeneric_OpNeg64_0(v)
+ return rewriteValuegeneric_OpNeg64(v)
case OpNeg64F:
- return rewriteValuegeneric_OpNeg64F_0(v)
+ return rewriteValuegeneric_OpNeg64F(v)
case OpNeg8:
- return rewriteValuegeneric_OpNeg8_0(v)
+ return rewriteValuegeneric_OpNeg8(v)
case OpNeq16:
- return rewriteValuegeneric_OpNeq16_0(v)
+ return rewriteValuegeneric_OpNeq16(v)
case OpNeq32:
- return rewriteValuegeneric_OpNeq32_0(v)
+ return rewriteValuegeneric_OpNeq32(v)
case OpNeq32F:
- return rewriteValuegeneric_OpNeq32F_0(v)
+ return rewriteValuegeneric_OpNeq32F(v)
case OpNeq64:
- return rewriteValuegeneric_OpNeq64_0(v)
+ return rewriteValuegeneric_OpNeq64(v)
case OpNeq64F:
- return rewriteValuegeneric_OpNeq64F_0(v)
+ return rewriteValuegeneric_OpNeq64F(v)
case OpNeq8:
- return rewriteValuegeneric_OpNeq8_0(v)
+ return rewriteValuegeneric_OpNeq8(v)
case OpNeqB:
- return rewriteValuegeneric_OpNeqB_0(v)
+ return rewriteValuegeneric_OpNeqB(v)
case OpNeqInter:
- return rewriteValuegeneric_OpNeqInter_0(v)
+ return rewriteValuegeneric_OpNeqInter(v)
case OpNeqPtr:
- return rewriteValuegeneric_OpNeqPtr_0(v) || rewriteValuegeneric_OpNeqPtr_10(v)
+ return rewriteValuegeneric_OpNeqPtr(v)
case OpNeqSlice:
- return rewriteValuegeneric_OpNeqSlice_0(v)
+ return rewriteValuegeneric_OpNeqSlice(v)
case OpNilCheck:
- return rewriteValuegeneric_OpNilCheck_0(v)
+ return rewriteValuegeneric_OpNilCheck(v)
case OpNot:
- return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
+ return rewriteValuegeneric_OpNot(v)
case OpOffPtr:
- return rewriteValuegeneric_OpOffPtr_0(v)
+ return rewriteValuegeneric_OpOffPtr(v)
case OpOr16:
- return rewriteValuegeneric_OpOr16_0(v)
+ return rewriteValuegeneric_OpOr16(v)
case OpOr32:
- return rewriteValuegeneric_OpOr32_0(v)
+ return rewriteValuegeneric_OpOr32(v)
case OpOr64:
- return rewriteValuegeneric_OpOr64_0(v)
+ return rewriteValuegeneric_OpOr64(v)
case OpOr8:
- return rewriteValuegeneric_OpOr8_0(v)
+ return rewriteValuegeneric_OpOr8(v)
case OpPhi:
- return rewriteValuegeneric_OpPhi_0(v)
+ return rewriteValuegeneric_OpPhi(v)
case OpPtrIndex:
- return rewriteValuegeneric_OpPtrIndex_0(v)
+ return rewriteValuegeneric_OpPtrIndex(v)
case OpRotateLeft16:
- return rewriteValuegeneric_OpRotateLeft16_0(v)
+ return rewriteValuegeneric_OpRotateLeft16(v)
case OpRotateLeft32:
- return rewriteValuegeneric_OpRotateLeft32_0(v)
+ return rewriteValuegeneric_OpRotateLeft32(v)
case OpRotateLeft64:
- return rewriteValuegeneric_OpRotateLeft64_0(v)
+ return rewriteValuegeneric_OpRotateLeft64(v)
case OpRotateLeft8:
- return rewriteValuegeneric_OpRotateLeft8_0(v)
+ return rewriteValuegeneric_OpRotateLeft8(v)
case OpRound32F:
- return rewriteValuegeneric_OpRound32F_0(v)
+ return rewriteValuegeneric_OpRound32F(v)
case OpRound64F:
- return rewriteValuegeneric_OpRound64F_0(v)
+ return rewriteValuegeneric_OpRound64F(v)
case OpRsh16Ux16:
- return rewriteValuegeneric_OpRsh16Ux16_0(v)
+ return rewriteValuegeneric_OpRsh16Ux16(v)
case OpRsh16Ux32:
- return rewriteValuegeneric_OpRsh16Ux32_0(v)
+ return rewriteValuegeneric_OpRsh16Ux32(v)
case OpRsh16Ux64:
- return rewriteValuegeneric_OpRsh16Ux64_0(v)
+ return rewriteValuegeneric_OpRsh16Ux64(v)
case OpRsh16Ux8:
- return rewriteValuegeneric_OpRsh16Ux8_0(v)
+ return rewriteValuegeneric_OpRsh16Ux8(v)
case OpRsh16x16:
- return rewriteValuegeneric_OpRsh16x16_0(v)
+ return rewriteValuegeneric_OpRsh16x16(v)
case OpRsh16x32:
- return rewriteValuegeneric_OpRsh16x32_0(v)
+ return rewriteValuegeneric_OpRsh16x32(v)
case OpRsh16x64:
- return rewriteValuegeneric_OpRsh16x64_0(v)
+ return rewriteValuegeneric_OpRsh16x64(v)
case OpRsh16x8:
- return rewriteValuegeneric_OpRsh16x8_0(v)
+ return rewriteValuegeneric_OpRsh16x8(v)
case OpRsh32Ux16:
- return rewriteValuegeneric_OpRsh32Ux16_0(v)
+ return rewriteValuegeneric_OpRsh32Ux16(v)
case OpRsh32Ux32:
- return rewriteValuegeneric_OpRsh32Ux32_0(v)
+ return rewriteValuegeneric_OpRsh32Ux32(v)
case OpRsh32Ux64:
- return rewriteValuegeneric_OpRsh32Ux64_0(v)
+ return rewriteValuegeneric_OpRsh32Ux64(v)
case OpRsh32Ux8:
- return rewriteValuegeneric_OpRsh32Ux8_0(v)
+ return rewriteValuegeneric_OpRsh32Ux8(v)
case OpRsh32x16:
- return rewriteValuegeneric_OpRsh32x16_0(v)
+ return rewriteValuegeneric_OpRsh32x16(v)
case OpRsh32x32:
- return rewriteValuegeneric_OpRsh32x32_0(v)
+ return rewriteValuegeneric_OpRsh32x32(v)
case OpRsh32x64:
- return rewriteValuegeneric_OpRsh32x64_0(v)
+ return rewriteValuegeneric_OpRsh32x64(v)
case OpRsh32x8:
- return rewriteValuegeneric_OpRsh32x8_0(v)
+ return rewriteValuegeneric_OpRsh32x8(v)
case OpRsh64Ux16:
- return rewriteValuegeneric_OpRsh64Ux16_0(v)
+ return rewriteValuegeneric_OpRsh64Ux16(v)
case OpRsh64Ux32:
- return rewriteValuegeneric_OpRsh64Ux32_0(v)
+ return rewriteValuegeneric_OpRsh64Ux32(v)
case OpRsh64Ux64:
- return rewriteValuegeneric_OpRsh64Ux64_0(v)
+ return rewriteValuegeneric_OpRsh64Ux64(v)
case OpRsh64Ux8:
- return rewriteValuegeneric_OpRsh64Ux8_0(v)
+ return rewriteValuegeneric_OpRsh64Ux8(v)
case OpRsh64x16:
- return rewriteValuegeneric_OpRsh64x16_0(v)
+ return rewriteValuegeneric_OpRsh64x16(v)
case OpRsh64x32:
- return rewriteValuegeneric_OpRsh64x32_0(v)
+ return rewriteValuegeneric_OpRsh64x32(v)
case OpRsh64x64:
- return rewriteValuegeneric_OpRsh64x64_0(v)
+ return rewriteValuegeneric_OpRsh64x64(v)
case OpRsh64x8:
- return rewriteValuegeneric_OpRsh64x8_0(v)
+ return rewriteValuegeneric_OpRsh64x8(v)
case OpRsh8Ux16:
- return rewriteValuegeneric_OpRsh8Ux16_0(v)
+ return rewriteValuegeneric_OpRsh8Ux16(v)
case OpRsh8Ux32:
- return rewriteValuegeneric_OpRsh8Ux32_0(v)
+ return rewriteValuegeneric_OpRsh8Ux32(v)
case OpRsh8Ux64:
- return rewriteValuegeneric_OpRsh8Ux64_0(v)
+ return rewriteValuegeneric_OpRsh8Ux64(v)
case OpRsh8Ux8:
- return rewriteValuegeneric_OpRsh8Ux8_0(v)
+ return rewriteValuegeneric_OpRsh8Ux8(v)
case OpRsh8x16:
- return rewriteValuegeneric_OpRsh8x16_0(v)
+ return rewriteValuegeneric_OpRsh8x16(v)
case OpRsh8x32:
- return rewriteValuegeneric_OpRsh8x32_0(v)
+ return rewriteValuegeneric_OpRsh8x32(v)
case OpRsh8x64:
- return rewriteValuegeneric_OpRsh8x64_0(v)
+ return rewriteValuegeneric_OpRsh8x64(v)
case OpRsh8x8:
- return rewriteValuegeneric_OpRsh8x8_0(v)
+ return rewriteValuegeneric_OpRsh8x8(v)
case OpSelect0:
- return rewriteValuegeneric_OpSelect0_0(v)
+ return rewriteValuegeneric_OpSelect0(v)
case OpSelect1:
- return rewriteValuegeneric_OpSelect1_0(v)
+ return rewriteValuegeneric_OpSelect1(v)
case OpSignExt16to32:
- return rewriteValuegeneric_OpSignExt16to32_0(v)
+ return rewriteValuegeneric_OpSignExt16to32(v)
case OpSignExt16to64:
- return rewriteValuegeneric_OpSignExt16to64_0(v)
+ return rewriteValuegeneric_OpSignExt16to64(v)
case OpSignExt32to64:
- return rewriteValuegeneric_OpSignExt32to64_0(v)
+ return rewriteValuegeneric_OpSignExt32to64(v)
case OpSignExt8to16:
- return rewriteValuegeneric_OpSignExt8to16_0(v)
+ return rewriteValuegeneric_OpSignExt8to16(v)
case OpSignExt8to32:
- return rewriteValuegeneric_OpSignExt8to32_0(v)
+ return rewriteValuegeneric_OpSignExt8to32(v)
case OpSignExt8to64:
- return rewriteValuegeneric_OpSignExt8to64_0(v)
+ return rewriteValuegeneric_OpSignExt8to64(v)
case OpSliceCap:
- return rewriteValuegeneric_OpSliceCap_0(v)
+ return rewriteValuegeneric_OpSliceCap(v)
case OpSliceLen:
- return rewriteValuegeneric_OpSliceLen_0(v)
+ return rewriteValuegeneric_OpSliceLen(v)
case OpSlicePtr:
- return rewriteValuegeneric_OpSlicePtr_0(v)
+ return rewriteValuegeneric_OpSlicePtr(v)
case OpSlicemask:
- return rewriteValuegeneric_OpSlicemask_0(v)
+ return rewriteValuegeneric_OpSlicemask(v)
case OpSqrt:
- return rewriteValuegeneric_OpSqrt_0(v)
+ return rewriteValuegeneric_OpSqrt(v)
case OpStaticCall:
- return rewriteValuegeneric_OpStaticCall_0(v)
+ return rewriteValuegeneric_OpStaticCall(v)
case OpStore:
- return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) || rewriteValuegeneric_OpStore_20(v)
+ return rewriteValuegeneric_OpStore(v)
case OpStringLen:
- return rewriteValuegeneric_OpStringLen_0(v)
+ return rewriteValuegeneric_OpStringLen(v)
case OpStringPtr:
- return rewriteValuegeneric_OpStringPtr_0(v)
+ return rewriteValuegeneric_OpStringPtr(v)
case OpStructSelect:
- return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
+ return rewriteValuegeneric_OpStructSelect(v)
case OpSub16:
- return rewriteValuegeneric_OpSub16_0(v)
+ return rewriteValuegeneric_OpSub16(v)
case OpSub32:
- return rewriteValuegeneric_OpSub32_0(v)
+ return rewriteValuegeneric_OpSub32(v)
case OpSub32F:
- return rewriteValuegeneric_OpSub32F_0(v)
+ return rewriteValuegeneric_OpSub32F(v)
case OpSub64:
- return rewriteValuegeneric_OpSub64_0(v)
+ return rewriteValuegeneric_OpSub64(v)
case OpSub64F:
- return rewriteValuegeneric_OpSub64F_0(v)
+ return rewriteValuegeneric_OpSub64F(v)
case OpSub8:
- return rewriteValuegeneric_OpSub8_0(v)
+ return rewriteValuegeneric_OpSub8(v)
case OpTrunc16to8:
- return rewriteValuegeneric_OpTrunc16to8_0(v)
+ return rewriteValuegeneric_OpTrunc16to8(v)
case OpTrunc32to16:
- return rewriteValuegeneric_OpTrunc32to16_0(v)
+ return rewriteValuegeneric_OpTrunc32to16(v)
case OpTrunc32to8:
- return rewriteValuegeneric_OpTrunc32to8_0(v)
+ return rewriteValuegeneric_OpTrunc32to8(v)
case OpTrunc64to16:
- return rewriteValuegeneric_OpTrunc64to16_0(v)
+ return rewriteValuegeneric_OpTrunc64to16(v)
case OpTrunc64to32:
- return rewriteValuegeneric_OpTrunc64to32_0(v)
+ return rewriteValuegeneric_OpTrunc64to32(v)
case OpTrunc64to8:
- return rewriteValuegeneric_OpTrunc64to8_0(v)
+ return rewriteValuegeneric_OpTrunc64to8(v)
case OpXor16:
- return rewriteValuegeneric_OpXor16_0(v)
+ return rewriteValuegeneric_OpXor16(v)
case OpXor32:
- return rewriteValuegeneric_OpXor32_0(v)
+ return rewriteValuegeneric_OpXor32(v)
case OpXor64:
- return rewriteValuegeneric_OpXor64_0(v)
+ return rewriteValuegeneric_OpXor64(v)
case OpXor8:
- return rewriteValuegeneric_OpXor8_0(v)
+ return rewriteValuegeneric_OpXor8(v)
case OpZero:
- return rewriteValuegeneric_OpZero_0(v)
+ return rewriteValuegeneric_OpZero(v)
case OpZeroExt16to32:
- return rewriteValuegeneric_OpZeroExt16to32_0(v)
+ return rewriteValuegeneric_OpZeroExt16to32(v)
case OpZeroExt16to64:
- return rewriteValuegeneric_OpZeroExt16to64_0(v)
+ return rewriteValuegeneric_OpZeroExt16to64(v)
case OpZeroExt32to64:
- return rewriteValuegeneric_OpZeroExt32to64_0(v)
+ return rewriteValuegeneric_OpZeroExt32to64(v)
case OpZeroExt8to16:
- return rewriteValuegeneric_OpZeroExt8to16_0(v)
+ return rewriteValuegeneric_OpZeroExt8to16(v)
case OpZeroExt8to32:
- return rewriteValuegeneric_OpZeroExt8to32_0(v)
+ return rewriteValuegeneric_OpZeroExt8to32(v)
case OpZeroExt8to64:
- return rewriteValuegeneric_OpZeroExt8to64_0(v)
+ return rewriteValuegeneric_OpZeroExt8to64(v)
}
return false
}
-func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -739,7 +739,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1005,7 +1005,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add32F (Const32F [c]) (Const32F [d]))
@@ -1028,7 +1028,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1294,7 +1294,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Add64F (Const64F [c]) (Const64F [d]))
@@ -1317,7 +1317,7 @@
}
return false
}
-func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
+func rewriteValuegeneric_OpAdd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1583,7 +1583,7 @@
}
return false
}
-func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
+func rewriteValuegeneric_OpAddPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (AddPtr <t> x (Const64 [c]))
@@ -1618,7 +1618,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
+func rewriteValuegeneric_OpAnd16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -1824,7 +1824,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
+func rewriteValuegeneric_OpAnd32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2030,7 +2030,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
+func rewriteValuegeneric_OpAnd64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2236,7 +2236,7 @@
}
return false
}
-func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
+func rewriteValuegeneric_OpAnd8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -2442,7 +2442,7 @@
}
return false
}
-func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
+func rewriteValuegeneric_OpArraySelect(v *Value) bool {
v_0 := v.Args[0]
// match: (ArraySelect (ArrayMake1 x))
// result: x
@@ -2469,7 +2469,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom16_0(v *Value) bool {
+func rewriteValuegeneric_OpCom16(v *Value) bool {
v_0 := v.Args[0]
// match: (Com16 (Com16 x))
// result: x
@@ -2516,7 +2516,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom32_0(v *Value) bool {
+func rewriteValuegeneric_OpCom32(v *Value) bool {
v_0 := v.Args[0]
// match: (Com32 (Com32 x))
// result: x
@@ -2563,7 +2563,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom64_0(v *Value) bool {
+func rewriteValuegeneric_OpCom64(v *Value) bool {
v_0 := v.Args[0]
// match: (Com64 (Com64 x))
// result: x
@@ -2610,7 +2610,7 @@
}
return false
}
-func rewriteValuegeneric_OpCom8_0(v *Value) bool {
+func rewriteValuegeneric_OpCom8(v *Value) bool {
v_0 := v.Args[0]
// match: (Com8 (Com8 x))
// result: x
@@ -2657,7 +2657,7 @@
}
return false
}
-func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
+func rewriteValuegeneric_OpConstInterface(v *Value) bool {
b := v.Block
typ := &b.Func.Config.Types
// match: (ConstInterface)
@@ -2671,7 +2671,7 @@
return true
}
}
-func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
+func rewriteValuegeneric_OpConstSlice(v *Value) bool {
b := v.Block
config := b.Func.Config
typ := &b.Func.Config.Types
@@ -2713,7 +2713,7 @@
}
return false
}
-func rewriteValuegeneric_OpConstString_0(v *Value) bool {
+func rewriteValuegeneric_OpConstString(v *Value) bool {
b := v.Block
config := b.Func.Config
fe := b.Func.fe
@@ -2790,7 +2790,7 @@
}
return false
}
-func rewriteValuegeneric_OpConvert_0(v *Value) bool {
+func rewriteValuegeneric_OpConvert(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Convert (Add64 (Convert ptr mem) off) mem)
@@ -2863,7 +2863,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt32Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto32 (Const32F [c]))
// result: (Const32 [int64(int32(auxTo32F(c)))])
@@ -2878,7 +2878,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt32Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64 (Const32F [c]))
// result: (Const64 [int64(auxTo32F(c))])
@@ -2893,7 +2893,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32Fto64F (Const32F [c]))
// result: (Const64F [c])
@@ -2908,7 +2908,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt32to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to32F (Const32 [c]))
// result: (Const32F [auxFrom32F(float32(int32(c)))])
@@ -2923,7 +2923,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt32to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt32to64F (Const32 [c]))
// result: (Const64F [auxFrom64F(float64(int32(c)))])
@@ -2938,7 +2938,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt64Fto32(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32 (Const64F [c]))
// result: (Const32 [int64(int32(auxTo64F(c)))])
@@ -2953,7 +2953,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto32F (Const64F [c]))
// result: (Const32F [auxFrom32F(float32(auxTo64F(c)))])
@@ -2968,7 +2968,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt64Fto64(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64Fto64 (Const64F [c]))
// result: (Const64 [int64(auxTo64F(c))])
@@ -2983,7 +2983,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt64to32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to32F (Const64 [c]))
// result: (Const32F [auxFrom32F(float32(c))])
@@ -2998,7 +2998,7 @@
}
return false
}
-func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool {
+func rewriteValuegeneric_OpCvt64to64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Cvt64to64F (Const64 [c]))
// result: (Const64F [auxFrom64F(float64(c))])
@@ -3013,7 +3013,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3171,7 +3171,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3344,7 +3344,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3574,7 +3574,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3615,7 +3615,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -3843,7 +3843,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4047,7 +4047,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4088,7 +4088,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4231,7 +4231,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4389,7 +4389,7 @@
}
return false
}
-func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
+func rewriteValuegeneric_OpDiv8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4462,7 +4462,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq16_0(v *Value) bool {
+func rewriteValuegeneric_OpEq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -4984,13 +4984,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpEq16_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Eq16 n (Lsh16x64 (Rsh16x64 (Add16 <t> n (Rsh16Ux64 <t> (Rsh16x64 <t> n (Const64 <typ.UInt64> [15])) (Const64 <typ.UInt64> [kbar]))) (Const64 <typ.UInt64> [k])) (Const64 <typ.UInt64> [k])) )
// cond: k > 0 && k < 15 && kbar == 16 - k
// result: (Eq16 (And16 <t> n (Const16 <t> [int64(1<<uint(k)-1)])) (Const16 <t> [0]))
@@ -5119,7 +5112,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq32_0(v *Value) bool {
+func rewriteValuegeneric_OpEq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -5714,13 +5707,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpEq32_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (Eq32 x (Mul32 (Const32 [c]) (Sub32 (Rsh32x64 mul:(Hmul32 (Const32 [m]) x) (Const64 [s])) (Rsh32x64 x (Const64 [31]))) ) )
// cond: v.Block.Func.pass.name != "opt" && mul.Uses == 1 && m == int64(int32(smagic(32,c).m/2)) && s == smagic(32,c).s-1 && x.Op != OpConst32 && sdivisibleOK(32,c)
// result: (Leq32U (RotateLeft32 <typ.UInt32> (Add32 <typ.UInt32> (Mul32 <typ.UInt32> (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).m))]) x) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).a))]) ) (Const32 <typ.UInt32> [int64(32-sdivisible(32,c).k)]) ) (Const32 <typ.UInt32> [int64(int32(sdivisible(32,c).max))]) )
@@ -6026,7 +6012,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq32F_0(v *Value) bool {
+func rewriteValuegeneric_OpEq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq32F (Const32F [c]) (Const32F [d]))
@@ -6049,7 +6035,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq64_0(v *Value) bool {
+func rewriteValuegeneric_OpEq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -6592,12 +6578,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpEq64_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (Eq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [y]))
// cond: isPowerOfTwo(y)
// result: (Neq64 (And64 <t> x (Const64 <t> [y])) (Const64 <t> [0]))
@@ -6636,7 +6616,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq64F_0(v *Value) bool {
+func rewriteValuegeneric_OpEq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Eq64F (Const64F [c]) (Const64F [d]))
@@ -6659,7 +6639,7 @@
}
return false
}
-func rewriteValuegeneric_OpEq8_0(v *Value) bool {
+func rewriteValuegeneric_OpEq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7075,7 +7055,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqB_0(v *Value) bool {
+func rewriteValuegeneric_OpEqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (EqB (ConstBool [c]) (ConstBool [d]))
@@ -7127,7 +7107,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
+func rewriteValuegeneric_OpEqInter(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7147,9 +7127,11 @@
return true
}
}
-func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
+func rewriteValuegeneric_OpEqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
+ b := v.Block
+ typ := &b.Func.Config.Types
// match: (EqPtr x x)
// result: (ConstBool [1])
for {
@@ -7367,13 +7349,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpEqPtr_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- typ := &b.Func.Config.Types
// match: (EqPtr (Const64 [c]) (Const64 [d]))
// result: (ConstBool [b2i(c == d)])
for {
@@ -7548,7 +7523,7 @@
}
return false
}
-func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
+func rewriteValuegeneric_OpEqSlice(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -7568,7 +7543,7 @@
return true
}
}
-func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq16 (Const16 [c]) (Const16 [d]))
@@ -7612,7 +7587,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq16U (Const16 [c]) (Const16 [d]))
@@ -7632,7 +7607,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq32 (Const32 [c]) (Const32 [d]))
@@ -7676,7 +7651,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq32F_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq32F (Const32F [c]) (Const32F [d]))
@@ -7696,7 +7671,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq32U (Const32 [c]) (Const32 [d]))
@@ -7716,7 +7691,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64 (Const64 [c]) (Const64 [d]))
@@ -7780,7 +7755,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq64F_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64F (Const64F [c]) (Const64F [d]))
@@ -7800,7 +7775,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq64U (Const64 [c]) (Const64 [d]))
@@ -7820,7 +7795,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq8 (Const8 [c]) (Const8 [d]))
@@ -7864,7 +7839,7 @@
}
return false
}
-func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
+func rewriteValuegeneric_OpGeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Geq8U (Const8 [c]) (Const8 [d]))
@@ -7884,7 +7859,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater16 (Const16 [c]) (Const16 [d]))
@@ -7904,7 +7879,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater16U (Const16 [c]) (Const16 [d]))
@@ -7924,7 +7899,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32 (Const32 [c]) (Const32 [d]))
@@ -7944,7 +7919,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater32F_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32F (Const32F [c]) (Const32F [d]))
@@ -7964,7 +7939,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater32U (Const32 [c]) (Const32 [d]))
@@ -7984,7 +7959,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64 (Const64 [c]) (Const64 [d]))
@@ -8004,7 +7979,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater64F_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64F (Const64F [c]) (Const64F [d]))
@@ -8024,7 +7999,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater64U (Const64 [c]) (Const64 [d]))
@@ -8044,7 +8019,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater8 (Const8 [c]) (Const8 [d]))
@@ -8064,7 +8039,7 @@
}
return false
}
-func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
+func rewriteValuegeneric_OpGreater8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Greater8U (Const8 [c]) (Const8 [d]))
@@ -8084,7 +8059,7 @@
}
return false
}
-func rewriteValuegeneric_OpIMake_0(v *Value) bool {
+func rewriteValuegeneric_OpIMake(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IMake typ (StructMake1 val))
@@ -8115,7 +8090,7 @@
}
return false
}
-func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
+func rewriteValuegeneric_OpInterCall(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
@@ -8162,7 +8137,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
+func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
@@ -8388,11 +8363,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (IsInBounds (ZeroExt16to32 (And16 (Const16 [c]) _)) (Const32 [d]))
// cond: 0 <= c && c < d
// result: (ConstBool [1])
@@ -8631,11 +8601,6 @@
v.AuxInt = 1
return true
}
- return false
-}
-func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (IsInBounds (ZeroExt8to32 (Rsh8Ux64 _ (Const64 [c]))) (Const32 [d]))
// cond: 0 < c && c < 8 && 1<<uint( 8-c)-1 < d
// result: (ConstBool [1])
@@ -8874,7 +8839,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
+func rewriteValuegeneric_OpIsNonNil(v *Value) bool {
v_0 := v.Args[0]
// match: (IsNonNil (ConstNil))
// result: (ConstBool [0])
@@ -8931,7 +8896,7 @@
}
return false
}
-func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
+func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (IsSliceInBounds x x)
@@ -9067,7 +9032,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq16 (Const16 [c]) (Const16 [d]))
@@ -9087,7 +9052,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq16U (Const16 [c]) (Const16 [d]))
@@ -9107,7 +9072,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32 (Const32 [c]) (Const32 [d]))
@@ -9127,7 +9092,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32F_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32F (Const32F [c]) (Const32F [d]))
@@ -9147,7 +9112,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq32U (Const32 [c]) (Const32 [d]))
@@ -9167,7 +9132,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64 (Const64 [c]) (Const64 [d]))
@@ -9187,7 +9152,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64F_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64F (Const64F [c]) (Const64F [d]))
@@ -9207,7 +9172,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq64U (Const64 [c]) (Const64 [d]))
@@ -9227,7 +9192,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq8 (Const8 [c]) (Const8 [d]))
@@ -9247,7 +9212,7 @@
}
return false
}
-func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
+func rewriteValuegeneric_OpLeq8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Leq8U (Const8 [c]) (Const8 [d]))
@@ -9267,7 +9232,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess16_0(v *Value) bool {
+func rewriteValuegeneric_OpLess16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less16 (Const16 [c]) (Const16 [d]))
@@ -9287,7 +9252,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
+func rewriteValuegeneric_OpLess16U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less16U (Const16 [c]) (Const16 [d]))
@@ -9307,7 +9272,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32_0(v *Value) bool {
+func rewriteValuegeneric_OpLess32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32 (Const32 [c]) (Const32 [d]))
@@ -9327,7 +9292,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32F_0(v *Value) bool {
+func rewriteValuegeneric_OpLess32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32F (Const32F [c]) (Const32F [d]))
@@ -9347,7 +9312,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
+func rewriteValuegeneric_OpLess32U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less32U (Const32 [c]) (Const32 [d]))
@@ -9367,7 +9332,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64_0(v *Value) bool {
+func rewriteValuegeneric_OpLess64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64 (Const64 [c]) (Const64 [d]))
@@ -9387,7 +9352,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64F_0(v *Value) bool {
+func rewriteValuegeneric_OpLess64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64F (Const64F [c]) (Const64F [d]))
@@ -9407,7 +9372,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
+func rewriteValuegeneric_OpLess64U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less64U (Const64 [c]) (Const64 [d]))
@@ -9427,7 +9392,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess8_0(v *Value) bool {
+func rewriteValuegeneric_OpLess8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less8 (Const8 [c]) (Const8 [d]))
@@ -9447,7 +9412,7 @@
}
return false
}
-func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
+func rewriteValuegeneric_OpLess8U(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Less8U (Const8 [c]) (Const8 [d]))
@@ -9467,7 +9432,7 @@
}
return false
}
-func rewriteValuegeneric_OpLoad_0(v *Value) bool {
+func rewriteValuegeneric_OpLoad(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -9777,13 +9742,6 @@
v0.AddArg(mem)
return true
}
- return false
-}
-func rewriteValuegeneric_OpLoad_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- fe := b.Func.fe
// match: (Load <t1> op:(OffPtr [o1] p1) (Store {t2} p2 _ (Store {t3} p3 _ (Store {t4} p4 _ mem:(Zero [n] p5 _)))))
// cond: o1 >= 0 && o1+t1.Size() <= n && isSamePtr(p1, p5) && fe.CanSSA(t1) && disjoint(op, t1.Size(), p2, sizeof(t2)) && disjoint(op, t1.Size(), p3, sizeof(t3)) && disjoint(op, t1.Size(), p4, sizeof(t4))
// result: @mem.Block (Load <t1> (OffPtr <op.Type> [o1] p5) mem)
@@ -10067,13 +10025,6 @@
v.reset(OpStructMake0)
return true
}
- return false
-}
-func rewriteValuegeneric_OpLoad_20(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- fe := b.Func.fe
// match: (Load <t> ptr mem)
// cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t)
// result: (StructMake1 (Load <t.FieldType(0)> (OffPtr <t.FieldType(0).PtrTo()> [0] ptr) mem))
@@ -10226,7 +10177,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10258,7 +10209,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10290,7 +10241,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10416,7 +10367,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10448,7 +10399,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10480,7 +10431,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10512,7 +10463,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10638,7 +10589,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10670,7 +10621,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10702,7 +10653,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10734,7 +10685,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10860,7 +10811,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10892,7 +10843,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10924,7 +10875,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -10956,7 +10907,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11082,7 +11033,7 @@
}
return false
}
-func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11114,7 +11065,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod16_0(v *Value) bool {
+func rewriteValuegeneric_OpMod16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11208,7 +11159,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
+func rewriteValuegeneric_OpMod16u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11281,7 +11232,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod32_0(v *Value) bool {
+func rewriteValuegeneric_OpMod32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11375,7 +11326,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
+func rewriteValuegeneric_OpMod32u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11448,7 +11399,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod64_0(v *Value) bool {
+func rewriteValuegeneric_OpMod64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11555,7 +11506,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
+func rewriteValuegeneric_OpMod64u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11643,7 +11594,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod8_0(v *Value) bool {
+func rewriteValuegeneric_OpMod8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11737,7 +11688,7 @@
}
return false
}
-func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
+func rewriteValuegeneric_OpMod8u(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -11810,11 +11761,12 @@
}
return false
}
-func rewriteValuegeneric_OpMove_0(v *Value) bool {
+func rewriteValuegeneric_OpMove(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
// match: (Move {t} [n] dst1 src mem:(Zero {t} [n] dst2 _))
// cond: isSamePtr(src, dst2)
// result: (Zero {t} [n] dst1 mem)
@@ -12257,13 +12209,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValuegeneric_OpMove_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} op2:(OffPtr <tt2> [o2] p2) d1 (Store {t3} op3:(OffPtr <tt3> [0] p3) d2 _))))
// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && o2 == sizeof(t3) && n == sizeof(t2) + sizeof(t3)
// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [0] dst) d2 mem))
@@ -13058,14 +13003,6 @@
v.AddArg(v1)
return true
}
- return false
-}
-func rewriteValuegeneric_OpMove_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
// match: (Move {t1} [n] dst p1 mem:(VarDef (Store {t2} (OffPtr <tt2> [o2] p2) d1 (Store {t3} (OffPtr <tt3> [o3] p3) d2 (Store {t4} (OffPtr <tt4> [o4] p4) d3 (Store {t5} (OffPtr <tt5> [o5] p5) d4 (Zero {t6} [n] p6 _)))))))
// cond: isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && isSamePtr(p4, p5) && isSamePtr(p5, p6) && alignof(t2) <= alignof(t1) && alignof(t3) <= alignof(t1) && alignof(t4) <= alignof(t1) && alignof(t5) <= alignof(t1) && alignof(t6) <= alignof(t1) && registerizable(b, t2) && registerizable(b, t3) && registerizable(b, t4) && registerizable(b, t5) && n >= o2 + sizeof(t2) && n >= o3 + sizeof(t3) && n >= o4 + sizeof(t4) && n >= o5 + sizeof(t5)
// result: (Store {t2} (OffPtr <tt2> [o2] dst) d1 (Store {t3} (OffPtr <tt3> [o3] dst) d2 (Store {t4} (OffPtr <tt4> [o4] dst) d3 (Store {t5} (OffPtr <tt5> [o5] dst) d4 (Zero {t1} [n] dst mem)))))
@@ -13258,7 +13195,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul16_0(v *Value) bool {
+func rewriteValuegeneric_OpMul16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13405,7 +13342,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32_0(v *Value) bool {
+func rewriteValuegeneric_OpMul32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13588,7 +13525,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
+func rewriteValuegeneric_OpMul32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul32F (Const32F [c]) (Const32F [d]))
@@ -13655,7 +13592,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64_0(v *Value) bool {
+func rewriteValuegeneric_OpMul64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -13838,7 +13775,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
+func rewriteValuegeneric_OpMul64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Mul64F (Const64F [c]) (Const64F [d]))
@@ -13905,7 +13842,7 @@
}
return false
}
-func rewriteValuegeneric_OpMul8_0(v *Value) bool {
+func rewriteValuegeneric_OpMul8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14052,7 +13989,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg16(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg16 (Const16 [c]))
@@ -14108,7 +14045,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg32(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg32 (Const32 [c]))
@@ -14164,7 +14101,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg32F (Const32F [c]))
// cond: auxTo32F(c) != 0
@@ -14183,7 +14120,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg64(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg64 (Const64 [c]))
@@ -14239,7 +14176,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Neg64F (Const64F [c]))
// cond: auxTo64F(c) != 0
@@ -14258,7 +14195,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
+func rewriteValuegeneric_OpNeg8(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
// match: (Neg8 (Const8 [c]))
@@ -14314,7 +14251,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14507,7 +14444,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14700,7 +14637,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq32F_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq32F (Const32F [c]) (Const32F [d]))
@@ -14723,7 +14660,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -14916,7 +14853,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq64F_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Neq64F (Const64F [c]) (Const64F [d]))
@@ -14939,7 +14876,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
+func rewriteValuegeneric_OpNeq8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15132,7 +15069,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
+func rewriteValuegeneric_OpNeqB(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqB (ConstBool [c]) (ConstBool [d]))
@@ -15203,7 +15140,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
+func rewriteValuegeneric_OpNeqInter(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15223,7 +15160,7 @@
return true
}
}
-func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
+func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (NeqPtr x x)
@@ -15443,11 +15380,6 @@
}
break
}
- return false
-}
-func rewriteValuegeneric_OpNeqPtr_10(v *Value) bool {
- v_1 := v.Args[1]
- v_0 := v.Args[0]
// match: (NeqPtr (Const64 [c]) (Const64 [d]))
// result: (ConstBool [b2i(c != d)])
for {
@@ -15614,7 +15546,7 @@
}
return false
}
-func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
+func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15634,7 +15566,7 @@
return true
}
}
-func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
+func rewriteValuegeneric_OpNilCheck(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -15717,7 +15649,7 @@
}
return false
}
-func rewriteValuegeneric_OpNot_0(v *Value) bool {
+func rewriteValuegeneric_OpNot(v *Value) bool {
v_0 := v.Args[0]
// match: (Not (ConstBool [c]))
// result: (ConstBool [1-c])
@@ -15847,10 +15779,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuegeneric_OpNot_10(v *Value) bool {
- v_0 := v.Args[0]
// match: (Not (Neq32 x y))
// result: (Eq32 x y)
for {
@@ -15981,10 +15909,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuegeneric_OpNot_20(v *Value) bool {
- v_0 := v.Args[0]
// match: (Not (Greater8 x y))
// result: (Leq8 x y)
for {
@@ -16115,10 +16039,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuegeneric_OpNot_30(v *Value) bool {
- v_0 := v.Args[0]
// match: (Not (Geq32U x y))
// result: (Less32U x y)
for {
@@ -16249,10 +16169,6 @@
v.AddArg(y)
return true
}
- return false
-}
-func rewriteValuegeneric_OpNot_40(v *Value) bool {
- v_0 := v.Args[0]
// match: (Not (Less8U x y))
// result: (Geq8U x y)
for {
@@ -16372,7 +16288,7 @@
}
return false
}
-func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
+func rewriteValuegeneric_OpOffPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (OffPtr (OffPtr p [b]) [a])
// result: (OffPtr p [a+b])
@@ -16406,7 +16322,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr16_0(v *Value) bool {
+func rewriteValuegeneric_OpOr16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16593,7 +16509,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr32_0(v *Value) bool {
+func rewriteValuegeneric_OpOr32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16780,7 +16696,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr64_0(v *Value) bool {
+func rewriteValuegeneric_OpOr64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -16967,7 +16883,7 @@
}
return false
}
-func rewriteValuegeneric_OpOr8_0(v *Value) bool {
+func rewriteValuegeneric_OpOr8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17154,7 +17070,7 @@
}
return false
}
-func rewriteValuegeneric_OpPhi_0(v *Value) bool {
+func rewriteValuegeneric_OpPhi(v *Value) bool {
// match: (Phi (Const8 [c]) (Const8 [c]))
// result: (Const8 [c])
for {
@@ -17225,7 +17141,7 @@
}
return false
}
-func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
+func rewriteValuegeneric_OpPtrIndex(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17273,7 +17189,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft16_0(v *Value) bool {
+func rewriteValuegeneric_OpRotateLeft16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft16 x (Const16 [c]))
@@ -17295,7 +17211,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft32_0(v *Value) bool {
+func rewriteValuegeneric_OpRotateLeft32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft32 x (Const32 [c]))
@@ -17317,7 +17233,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft64_0(v *Value) bool {
+func rewriteValuegeneric_OpRotateLeft64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft64 x (Const64 [c]))
@@ -17339,7 +17255,7 @@
}
return false
}
-func rewriteValuegeneric_OpRotateLeft8_0(v *Value) bool {
+func rewriteValuegeneric_OpRotateLeft8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (RotateLeft8 x (Const8 [c]))
@@ -17361,7 +17277,7 @@
}
return false
}
-func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
+func rewriteValuegeneric_OpRound32F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round32F x:(Const32F))
// result: x
@@ -17377,7 +17293,7 @@
}
return false
}
-func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
+func rewriteValuegeneric_OpRound64F(v *Value) bool {
v_0 := v.Args[0]
// match: (Round64F x:(Const64F))
// result: x
@@ -17393,7 +17309,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17425,7 +17341,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17457,7 +17373,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17623,7 +17539,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17655,7 +17571,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17687,7 +17603,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17719,7 +17635,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17810,7 +17726,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17842,7 +17758,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17874,7 +17790,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -17906,7 +17822,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18090,7 +18006,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18122,7 +18038,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18154,7 +18070,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18186,7 +18102,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18295,7 +18211,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18327,7 +18243,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18359,7 +18275,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18391,7 +18307,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18593,7 +18509,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18625,7 +18541,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18657,7 +18573,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18689,7 +18605,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18816,7 +18732,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18848,7 +18764,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18880,7 +18796,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -18912,7 +18828,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19060,7 +18976,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19092,7 +19008,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19124,7 +19040,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19156,7 +19072,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19228,7 +19144,7 @@
}
return false
}
-func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -19260,7 +19176,7 @@
}
return false
}
-func rewriteValuegeneric_OpSelect0_0(v *Value) bool {
+func rewriteValuegeneric_OpSelect0(v *Value) bool {
v_0 := v.Args[0]
// match: (Select0 (Div128u (Const64 [0]) lo y))
// result: (Div64u lo y)
@@ -19281,7 +19197,7 @@
}
return false
}
-func rewriteValuegeneric_OpSelect1_0(v *Value) bool {
+func rewriteValuegeneric_OpSelect1(v *Value) bool {
v_0 := v.Args[0]
// match: (Select1 (Div128u (Const64 [0]) lo y))
// result: (Mod64u lo y)
@@ -19302,7 +19218,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to32 (Const16 [c]))
// result: (Const32 [int64( int16(c))])
@@ -19342,7 +19258,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt16to64 (Const16 [c]))
// result: (Const64 [int64( int16(c))])
@@ -19382,7 +19298,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt32to64 (Const32 [c]))
// result: (Const64 [int64( int32(c))])
@@ -19422,7 +19338,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to16 (Const8 [c]))
// result: (Const16 [int64( int8(c))])
@@ -19462,7 +19378,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to32 (Const8 [c]))
// result: (Const32 [int64( int8(c))])
@@ -19502,7 +19418,7 @@
}
return false
}
-func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (SignExt8to64 (Const8 [c]))
// result: (Const64 [int64( int8(c))])
@@ -19542,7 +19458,7 @@
}
return false
}
-func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
+func rewriteValuegeneric_OpSliceCap(v *Value) bool {
v_0 := v.Args[0]
// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
// result: (Const64 <t> [c])
@@ -19614,7 +19530,7 @@
}
return false
}
-func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
+func rewriteValuegeneric_OpSliceLen(v *Value) bool {
v_0 := v.Args[0]
// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
// result: (Const64 <t> [c])
@@ -19670,7 +19586,7 @@
}
return false
}
-func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
+func rewriteValuegeneric_OpSlicePtr(v *Value) bool {
v_0 := v.Args[0]
// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
// result: (SlicePtr x)
@@ -19690,7 +19606,7 @@
}
return false
}
-func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
+func rewriteValuegeneric_OpSlicemask(v *Value) bool {
v_0 := v.Args[0]
// match: (Slicemask (Const32 [x]))
// cond: x > 0
@@ -19744,7 +19660,7 @@
}
return false
}
-func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
+func rewriteValuegeneric_OpSqrt(v *Value) bool {
v_0 := v.Args[0]
// match: (Sqrt (Const64F [c]))
// result: (Const64F [auxFrom64F(math.Sqrt(auxTo64F(c)))])
@@ -19759,7 +19675,7 @@
}
return false
}
-func rewriteValuegeneric_OpStaticCall_0(v *Value) bool {
+func rewriteValuegeneric_OpStaticCall(v *Value) bool {
v_0 := v.Args[0]
b := v.Block
config := b.Func.Config
@@ -19857,11 +19773,13 @@
}
return false
}
-func rewriteValuegeneric_OpStore_0(v *Value) bool {
+func rewriteValuegeneric_OpStore(v *Value) bool {
v_2 := v.Args[2]
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
+ config := b.Func.Config
+ fe := b.Func.fe
// match: (Store {t1} p1 (Load <t2> p2 mem) mem)
// cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1)
// result: mem
@@ -20165,15 +20083,6 @@
v.AddArg(mem)
return true
}
- return false
-}
-func rewriteValuegeneric_OpStore_10(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
- config := b.Func.Config
- fe := b.Func.fe
// match: (Store dst (StructMake2 <t> f0 f1) mem)
// result: (Store {t.FieldType(1)} (OffPtr <t.FieldType(1).PtrTo()> [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr <t.FieldType(0).PtrTo()> [0] dst) f0 mem))
for {
@@ -20469,13 +20378,6 @@
v.AddArg(v0)
return true
}
- return false
-}
-func rewriteValuegeneric_OpStore_20(v *Value) bool {
- v_2 := v.Args[2]
- v_1 := v.Args[1]
- v_0 := v.Args[0]
- b := v.Block
// match: (Store {t1} op1:(OffPtr [o1] p1) d1 m2:(Store {t2} op2:(OffPtr [o2] p2) d2 m3:(Store {t3} op3:(OffPtr [0] p3) d3 m4:(Move [n] p4 _ mem))))
// cond: m2.Uses == 1 && m3.Uses == 1 && m4.Uses == 1 && o2 == sizeof(t3) && o1-o2 == sizeof(t2) && n == sizeof(t3) + sizeof(t2) + sizeof(t1) && isSamePtr(p1, p2) && isSamePtr(p2, p3) && isSamePtr(p3, p4) && clobber(m2) && clobber(m3) && clobber(m4)
// result: (Store {t1} op1 d1 (Store {t2} op2 d2 (Store {t3} op3 d3 mem)))
@@ -20816,7 +20718,7 @@
}
return false
}
-func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
+func rewriteValuegeneric_OpStringLen(v *Value) bool {
v_0 := v.Args[0]
// match: (StringLen (StringMake _ (Const64 <t> [c])))
// result: (Const64 <t> [c])
@@ -20838,7 +20740,7 @@
}
return false
}
-func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
+func rewriteValuegeneric_OpStringPtr(v *Value) bool {
v_0 := v.Args[0]
// match: (StringPtr (StringMake (Addr <t> {s} base) _))
// result: (Addr <t> {s} base)
@@ -20862,8 +20764,10 @@
}
return false
}
-func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
+func rewriteValuegeneric_OpStructSelect(v *Value) bool {
v_0 := v.Args[0]
+ b := v.Block
+ fe := b.Func.fe
// match: (StructSelect (StructMake1 x))
// result: x
for {
@@ -20990,12 +20894,6 @@
v.AddArg(x)
return true
}
- return false
-}
-func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
- v_0 := v.Args[0]
- b := v.Block
- fe := b.Func.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)
@@ -21035,7 +20933,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub16_0(v *Value) bool {
+func rewriteValuegeneric_OpSub16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21266,7 +21164,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub32_0(v *Value) bool {
+func rewriteValuegeneric_OpSub32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21497,7 +21395,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
+func rewriteValuegeneric_OpSub32F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub32F (Const32F [c]) (Const32F [d]))
@@ -21517,7 +21415,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub64_0(v *Value) bool {
+func rewriteValuegeneric_OpSub64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21748,7 +21646,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
+func rewriteValuegeneric_OpSub64F(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
// match: (Sub64F (Const64F [c]) (Const64F [d]))
@@ -21768,7 +21666,7 @@
}
return false
}
-func rewriteValuegeneric_OpSub8_0(v *Value) bool {
+func rewriteValuegeneric_OpSub8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -21999,7 +21897,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc16to8 (Const16 [c]))
// result: (Const8 [int64(int8(c))])
@@ -22063,7 +21961,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to16 (Const32 [c]))
// result: (Const16 [int64(int16(c))])
@@ -22149,7 +22047,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc32to8 (Const32 [c]))
// result: (Const8 [int64(int8(c))])
@@ -22213,7 +22111,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to16 (Const64 [c]))
// result: (Const16 [int64(int16(c))])
@@ -22299,7 +22197,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to32 (Const64 [c]))
// result: (Const32 [int64(int32(c))])
@@ -22407,7 +22305,7 @@
}
return false
}
-func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
v_0 := v.Args[0]
// match: (Trunc64to8 (Const64 [c]))
// result: (Const8 [int64(int8(c))])
@@ -22471,7 +22369,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor16_0(v *Value) bool {
+func rewriteValuegeneric_OpXor16(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22609,7 +22507,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor32_0(v *Value) bool {
+func rewriteValuegeneric_OpXor32(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22747,7 +22645,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor64_0(v *Value) bool {
+func rewriteValuegeneric_OpXor64(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -22885,7 +22783,7 @@
}
return false
}
-func rewriteValuegeneric_OpXor8_0(v *Value) bool {
+func rewriteValuegeneric_OpXor8(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23023,7 +22921,7 @@
}
return false
}
-func rewriteValuegeneric_OpZero_0(v *Value) bool {
+func rewriteValuegeneric_OpZero(v *Value) bool {
v_1 := v.Args[1]
v_0 := v.Args[0]
b := v.Block
@@ -23135,7 +23033,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to32 (Const16 [c]))
// result: (Const32 [int64(uint16(c))])
@@ -23175,7 +23073,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt16to64 (Const16 [c]))
// result: (Const64 [int64(uint16(c))])
@@ -23215,7 +23113,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt32to64 (Const32 [c]))
// result: (Const64 [int64(uint32(c))])
@@ -23255,7 +23153,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to16 (Const8 [c]))
// result: (Const16 [int64( uint8(c))])
@@ -23295,7 +23193,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to32 (Const8 [c]))
// result: (Const32 [int64( uint8(c))])
@@ -23335,7 +23233,7 @@
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool {
v_0 := v.Args[0]
// match: (ZeroExt8to64 (Const8 [c]))
// result: (Const64 [int64( uint8(c))])
