From 6dd11bcb35cba37f5994c1b9aaaf7d2dc13fd7cf Mon Sep 17 00:00:00 2001 From: Josh Bleecher Snyder Date: Tue, 21 Jan 2020 20:53:30 -0800 Subject: [PATCH] cmd/compile: remove chunking of rewrite rules MIME-Version: 1.0 Content-Type: text/plain; charset=utf8 Content-Transfer-Encoding: 8bit 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 TryBot-Result: Gobot Gobot Reviewed-by: Keith Randall --- src/cmd/compile/internal/ssa/gen/rulegen.go | 72 +- src/cmd/compile/internal/ssa/rewrite386.go | 1461 ++++++------ .../internal/ssa/rewrite386splitload.go | 24 +- src/cmd/compile/internal/ssa/rewriteAMD64.go | 2099 ++++++++-------- .../internal/ssa/rewriteAMD64splitload.go | 32 +- src/cmd/compile/internal/ssa/rewriteARM.go | 1719 +++++++------- src/cmd/compile/internal/ssa/rewriteARM64.go | 2108 ++++++++--------- src/cmd/compile/internal/ssa/rewriteMIPS.go | 1051 ++++---- src/cmd/compile/internal/ssa/rewriteMIPS64.go | 1243 +++++----- src/cmd/compile/internal/ssa/rewritePPC64.go | 1543 ++++++------ .../compile/internal/ssa/rewriteRISCV64.go | 1000 ++++---- src/cmd/compile/internal/ssa/rewriteS390X.go | 1703 +++++++------ src/cmd/compile/internal/ssa/rewriteWasm.go | 1147 +++++---- src/cmd/compile/internal/ssa/rewritedec.go | 44 +- src/cmd/compile/internal/ssa/rewritedec64.go | 232 +- .../compile/internal/ssa/rewritedecArgs.go | 9 +- .../compile/internal/ssa/rewritegeneric.go | 1040 ++++---- 17 files changed, 7786 insertions(+), 8741 deletions(-) diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index f1cfa1824a..2e5f3d24f3 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -170,7 +170,6 @@ func genRulesSuffix(arch arch, suff string) { 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 @@ func genRulesSuffix(arch arch, suff string) { 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 @@ func genRulesSuffix(arch arch, suff string) { 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", 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) } - fn := &Func{ - kind: "Value", - suffix: fmt.Sprintf("_%s_%d", op, chunk), - arglen: opByName(arch, op).argLength, + 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" } - 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.cond != "" { + rr.add(breakf("!(%s)", rr.cond)) } - if rr.canFail { - fn.add(stmtf("return false")) + genResult(rr, arch, rr.result, pos) + if *genLog { + rr.add(stmtf("logRule(%q)", rule.loc)) } - genFile.add(fn) + 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 35de8bcd91..02716a3e30 100644 --- a/src/cmd/compile/internal/ssa/rewrite386.go +++ b/src/cmd/compile/internal/ssa/rewrite386.go @@ -9,705 +9,705 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValue386_Op386ADCL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDL_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLcarry_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLconstmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDLmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDSD_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDSDload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDSS_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ADDSSload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLconstmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ANDLmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPB_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPBconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPBload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPLconst_0(v *Value) bool { 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 @@ func rewriteValue386_Op386CMPLconst_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPW_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPWconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386CMPWload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386DIVSD_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386DIVSDload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386DIVSS_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386DIVSSload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386LEAL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386LEAL1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386LEAL2_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386LEAL4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386LEAL8_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBLSX_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBLZX_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBstore_0(v *Value) bool { 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 @@ func rewriteValue386_Op386MOVBstore_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstore_0(v *Value) bool { 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 @@ func rewriteValue386_Op386MOVLstore_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVLstoreidx4_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDstore_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSstore_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWLSX_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWLZX_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstore_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULLconst_0(v *Value) bool { 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 @@ func rewriteValue386_Op386MULLconst_10(v *Value) bool { 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 x x)) for { @@ -9747,10 +9709,6 @@ func rewriteValue386_Op386MULLconst_20(v *Value) bool { 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 @@ func rewriteValue386_Op386MULLconst_30(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULSD_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULSDload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULSS_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386MULSSload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386NEGL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386NOTL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORL_0(v *Value) bool { } 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 [i0] {s} p idx mem) @@ -10558,7 +10510,7 @@ func rewriteValue386_Op386ORL_10(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLconstmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ORLmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ROLBconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ROLLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386ROLWconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARB_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARBconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARW_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SARWconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SBBL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETA_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETAE_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETB_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETBE_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETEQ_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETG_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETGE_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETLE_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SETNE_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHLL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHLLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRB_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRBconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRW_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SHRWconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBLcarry_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBLconst_0(v *Value) bool { 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 @@ func rewriteValue386_Op386SUBLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBLmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBLmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBSD_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBSDload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBSS_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386SUBSSload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORL_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLconst_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLconstmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLload_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLmodify_0(v *Value) bool { } 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 @@ func rewriteValue386_Op386XORLmodifyidx4_0(v *Value) bool { } 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 @@ func rewriteValue386_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd32carry_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd32withcarry_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValue386_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpAddr_0(v *Value) bool { 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 @@ func rewriteValue386_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValue386_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValue386_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValue386_OpAndB_0(v *Value) bool { 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 @@ func rewriteValue386_OpAvg32u_0(v *Value) bool { 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 @@ func rewriteValue386_OpBswap32_0(v *Value) bool { 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 @@ func rewriteValue386_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValue386_OpCom16_0(v *Value) bool { 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 @@ func rewriteValue386_OpCom32_0(v *Value) bool { 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 @@ func rewriteValue386_OpCom8_0(v *Value) bool { 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 @@ func rewriteValue386_OpConst16_0(v *Value) bool { 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 @@ func rewriteValue386_OpConst32_0(v *Value) bool { 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 @@ func rewriteValue386_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpConst8_0(v *Value) bool { 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 @@ func rewriteValue386_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValue386_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValue386_OpCtz16_0(v *Value) bool { 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 @@ func rewriteValue386_OpCtz16NonZero_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValue386_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValue386_OpEq16_0(v *Value) bool { 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 @@ func rewriteValue386_OpEq32_0(v *Value) bool { 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 @@ func rewriteValue386_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpEq8_0(v *Value) bool { 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 @@ func rewriteValue386_OpEqB_0(v *Value) bool { 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 @@ func rewriteValue386_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValue386_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValue386_OpGetCallerPC_0(v *Value) bool { +func rewriteValue386_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -14391,7 +14343,7 @@ func rewriteValue386_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValue386_OpGetCallerSP_0(v *Value) bool { +func rewriteValue386_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -14399,7 +14351,7 @@ func rewriteValue386_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValue386_OpGetClosurePtr_0(v *Value) bool { +func rewriteValue386_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -14407,7 +14359,7 @@ func rewriteValue386_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpGetG_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValue386_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValue386_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValue386_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValue386_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValue386_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValue386_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValue386_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess16_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess32_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess8_0(v *Value) bool { 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 @@ func rewriteValue386_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -14999,7 +14951,7 @@ func rewriteValue386_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValue386_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod16_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod32_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod8_0(v *Value) bool { 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 @@ func rewriteValue386_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValue386_OpMove_0(v *Value) bool { 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 @@ func rewriteValue386_OpMove_10(v *Value) bool { } 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 @@ func rewriteValue386_OpMul16_0(v *Value) bool { 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 @@ func rewriteValue386_OpMul32_0(v *Value) bool { 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 @@ func rewriteValue386_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpMul32uhilo_0(v *Value) bool { 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 @@ func rewriteValue386_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpMul8_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeg32F_0(v *Value) bool { } 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 @@ func rewriteValue386_OpNeg64F_0(v *Value) bool { } 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 @@ func rewriteValue386_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValue386_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValue386_OpNot_0(v *Value) bool { 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 @@ func rewriteValue386_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpOr16_0(v *Value) bool { 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 @@ func rewriteValue386_OpOr32_0(v *Value) bool { 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 @@ func rewriteValue386_OpOr8_0(v *Value) bool { 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 @@ func rewriteValue386_OpOrB_0(v *Value) bool { 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 @@ func rewriteValue386_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValue386_OpPanicExtend_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRotateLeft32_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValue386_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValue386_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValue386_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValue386_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValue386_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValue386_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValue386_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValue386_OpSignmask_0(v *Value) bool { 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 x) @@ -17123,7 +17067,7 @@ func rewriteValue386_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValue386_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValue386_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValue386_OpStore_0(v *Value) bool { } 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 @@ func rewriteValue386_OpSub16_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub32_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub32carry_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub32withcarry_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValue386_OpSub8_0(v *Value) bool { 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 @@ func rewriteValue386_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValue386_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValue386_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValue386_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValue386_OpWB_0(v *Value) bool { 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 @@ func rewriteValue386_OpXor16_0(v *Value) bool { 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 @@ func rewriteValue386_OpXor32_0(v *Value) bool { 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 @@ func rewriteValue386_OpXor8_0(v *Value) bool { 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 @@ func rewriteValue386_OpZero_0(v *Value) bool { 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 @@ func rewriteValue386_OpZero_10(v *Value) bool { } 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 @@ func rewriteValue386_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValue386_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValue386_OpZeroExt8to32_0(v *Value) bool { 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 x) diff --git a/src/cmd/compile/internal/ssa/rewrite386splitload.go b/src/cmd/compile/internal/ssa/rewrite386splitload.go index 9f1c71aa18..cce1b2d05a 100644 --- a/src/cmd/compile/internal/ssa/rewrite386splitload.go +++ b/src/cmd/compile/internal/ssa/rewrite386splitload.go @@ -6,21 +6,21 @@ package ssa 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 @@ func rewriteValue386splitload_Op386CMPBconstload_0(v *Value) bool { 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 @@ func rewriteValue386splitload_Op386CMPBload_0(v *Value) bool { 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 @@ func rewriteValue386splitload_Op386CMPLconstload_0(v *Value) bool { 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 @@ func rewriteValue386splitload_Op386CMPLload_0(v *Value) bool { 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 @@ func rewriteValue386splitload_Op386CMPWconstload_0(v *Value) bool { 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 3c2e57b1c3..df9f0d0f34 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -9,589 +9,589 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { 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 @@ func rewriteValueAMD64(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADCQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADCQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64ADDLconst_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDLload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDLmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQcarry_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64ADDQconst_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDQmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDSDload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ADDSSload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDLload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDLmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDQconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ANDQmodify_0(v *Value) bool { } 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 [1<<8] (MOVBQZX x))) @@ -3700,7 +3682,7 @@ func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool { } 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< w) mem) @@ -11703,12 +11664,6 @@ func rewriteValueAMD64_OpAMD64MOVBstore_20(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVBstore_30(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVBstoreidx1_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLQSXload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLatomicload_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -12982,7 +12930,7 @@ func rewriteValueAMD64_OpAMD64MOVLf2i_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -13009,9 +12957,11 @@ func rewriteValueAMD64_OpAMD64MOVLi2f_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLload_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVLload_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLloadidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstore_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstore_20(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVLstore_30(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVLstoreidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVOload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVOstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQatomicload_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -15611,7 +15537,7 @@ func rewriteValueAMD64_OpAMD64MOVQf2i_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -15638,7 +15564,7 @@ func rewriteValueAMD64_OpAMD64MOVQi2f_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstore_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVQstore_10(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVQstore_20(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWQSXload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstore_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MOVWstore_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULLconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MULLconst_10(v *Value) bool { 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 x x)) for { @@ -21247,10 +21145,6 @@ func rewriteValueAMD64_OpAMD64MULLconst_20(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MULLconst_30(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULQconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MULQconst_10(v *Value) bool { 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 x x)) for { @@ -21757,10 +21641,6 @@ func rewriteValueAMD64_OpAMD64MULQconst_20(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64MULQconst_30(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULSDload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64MULSSload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool { } 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 (SHLLconst [j1] (ROLWconst [8] (MOVWloadidx1 [i0] {s} p idx mem))) y) @@ -23662,7 +23523,7 @@ func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORLload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORLmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool { } 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 (MOVLload [i0] {s} p mem)) @@ -25470,7 +25317,7 @@ func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ORQmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SBBQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SBBQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETAEstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETAstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETBEstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETBstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETEQstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETEQstore_10(v *Value) bool { 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 [0]) mem) for { @@ -29078,7 +28905,7 @@ func rewriteValueAMD64_OpAMD64SETEQstore_20(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETGEstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETGstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETLEstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETLstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETNEstore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SETNEstore_10(v *Value) bool { 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 [1]) mem) for { @@ -31100,7 +30907,7 @@ func rewriteValueAMD64_OpAMD64SETNEstore_20(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64SUBLload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBLmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBQborrow_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBQmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBSDload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64SUBSSload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTBconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTLconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64TESTWconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAMD64XORLconst_10(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORLconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORLload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORLmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORQconstmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORQload_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAMD64XORQmodify_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpBitLen16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpBitLen32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpBitLen8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpCeil_0(v *Value) bool { 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 x y (SETEQ cond)) // cond: (is64BitInt(t) || isPtr(t)) // result: (CMOVQEQ y x cond) @@ -34791,12 +34596,6 @@ func rewriteValueAMD64_OpCondSelect_0(v *Value) bool { 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 x y (SETEQF cond)) // cond: (is64BitInt(t) || isPtr(t)) // result: (CMOVQEQF y x cond) @@ -34997,12 +34796,6 @@ func rewriteValueAMD64_OpCondSelect_10(v *Value) bool { 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 x y (SETA cond)) // cond: is32BitInt(t) // result: (CMOVLHI y x cond) @@ -35203,12 +34996,6 @@ func rewriteValueAMD64_OpCondSelect_20(v *Value) bool { 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 x y (SETL cond)) // cond: is16BitInt(t) // result: (CMOVWLT y x cond) @@ -35409,14 +35196,6 @@ func rewriteValueAMD64_OpCondSelect_30(v *Value) bool { 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 x y (SETGF cond)) // cond: is16BitInt(t) // result: (CMOVWGTF y x cond) @@ -35579,7 +35358,7 @@ func rewriteValueAMD64_OpCondSelect_40(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpCtz16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpCtz8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpFMA_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpFloor_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGeq8U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -36817,7 +36596,7 @@ func rewriteValueAMD64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMove_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpMove_10(v *Value) bool { 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 [s%16]) (OffPtr src [s%16]) (MOVQstore [8] dst (MOVQload [8] src mem) (MOVQstore dst (MOVQload src mem) mem))) @@ -38287,7 +38048,7 @@ func rewriteValueAMD64_OpMove_20(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpNot_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpPopCount16_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpPopCount8_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpRoundToEven_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpSelect1_0(v *Value) bool { } 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 x) @@ -40301,7 +40062,7 @@ func rewriteValueAMD64_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueAMD64_OpTrunc_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpZero_0(v *Value) bool { 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 @@ func rewriteValueAMD64_OpZero_10(v *Value) bool { 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 ec7d2270b3..69df3f7a1e 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64splitload.go @@ -6,25 +6,25 @@ package ssa 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPBconstload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPBload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPLconstload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPLload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPQconstload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPQload_0(v *Value) bool { 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 @@ func rewriteValueAMD64splitload_OpAMD64CMPWconstload_0(v *Value) bool { 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 76befe077b..c864f1e0f3 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM.go +++ b/src/cmd/compile/internal/ssa/rewriteARM.go @@ -9,837 +9,837 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueARM_OpARMADC_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDS_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMAND_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMAND_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBFX_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBFXU_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBIC_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMN_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMNshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMP_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMCMP_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMLessEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMLessThan_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMLessThanU_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBUloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVBstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVDload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVFload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHUloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVHstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWload_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMUL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMUL_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMULA_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMMULA_10(v *Value) bool { 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 @@ func rewriteValueARM_OpARMMULA_20(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMULD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMULF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMULS_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMMULS_10(v *Value) bool { 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 @@ func rewriteValueARM_OpARMMULS_20(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMVN_0(v *Value) bool { } 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))]) @@ -9107,7 +9065,7 @@ func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMNEGD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMNEGF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMNMULD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMNMULF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMNotEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMOR_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMRSB_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBC_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMSBC_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSLL_0(v *Value) bool { } 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))]) @@ -11655,7 +11602,7 @@ func rewriteValueARM_OpARMSRAconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSRLconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMSUB_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBD_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBF_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBS_0(v *Value) bool { 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 @@ func rewriteValueARM_OpARMSUBS_10(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQ_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTEQshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTST_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMTSTshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXOR_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORconst_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpAbs_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd32carry_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpAvg32u_0(v *Value) bool { 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 x) @@ -14490,7 +14427,7 @@ func rewriteValueARM_OpBitLen32_0(v *Value) bool { 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 x) @@ -14537,7 +14474,7 @@ func rewriteValueARM_OpBswap32_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueARM_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCtz16_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpCtz16NonZero_0(v *Value) bool { 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 x) @@ -14771,7 +14708,7 @@ func rewriteValueARM_OpCtz32_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpCtz32NonZero_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCtz8_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpCtz8NonZero_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpFMA_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueARM_OpGetCallerPC_0(v *Value) bool { +func rewriteValueARM_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -15452,7 +15389,7 @@ func rewriteValueARM_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueARM_OpGetCallerSP_0(v *Value) bool { +func rewriteValueARM_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -15460,7 +15397,7 @@ func rewriteValueARM_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueARM_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -15468,7 +15405,7 @@ func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueARM_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueARM_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -16154,7 +16091,7 @@ func rewriteValueARM_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMove_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMul32uhilo_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueARM_OpNot_0(v *Value) bool { 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 @@ func rewriteValueARM_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpPanicExtend_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRotateLeft32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSignmask_0(v *Value) bool { 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 x) @@ -18367,7 +18304,7 @@ func rewriteValueARM_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueARM_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueARM_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub32carry_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub32withcarry_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueARM_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpWB_0(v *Value) bool { 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 @@ func rewriteValueARM_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueARM_OpZero_0(v *Value) bool { } 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 @@ func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool { 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 87e15d911a..6e69eabe47 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM64.go +++ b/src/cmd/compile/internal/ssa/rewriteARM64.go @@ -8,955 +8,955 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueARM64_OpARM64ADCSflags_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ADD_0(v *Value) bool { } 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 x (ANDconst [63] y)) (CSEL0 {cc} (SLL x (SUB (MOVDconst [64]) (ANDconst [63] y))) (CMPconst [64] (SUB (MOVDconst [64]) (ANDconst [63] y))))) // cond: cc.(Op) == OpARM64LessThanU // result: (ROR x y) @@ -1500,7 +1493,7 @@ func rewriteValueARM64_OpARM64ADD_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64AND_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64BIC_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64BICshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64BICshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMN_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNWconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMNshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMP_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CSEL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64CSEL0_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64DIV_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64EON_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64EONshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64EONshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64EONshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64Equal_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FADDD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FADDS_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FCMPD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FCMPS_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -4024,7 +4017,7 @@ func rewriteValueARM64_OpARM64FMOVDfpgp_0(v *Value) bool { } 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 (Arg [off] {sym})) @@ -4046,7 +4039,7 @@ func rewriteValueARM64_OpARM64FMOVDgpfp_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVDloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVDstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVSloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMOVSstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMULD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FMULS_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FNEGD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FNEGS_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FNMULD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FNMULS_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FSUBD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64FSUBS_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterEqualF_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterThanF_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessEqualF_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessThanF_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MADD_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MADD_10(v *Value) bool { 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 y)) for { @@ -5875,7 +5854,7 @@ func rewriteValueARM64_OpARM64MADD_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MADDW_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MADDW_10(v *Value) bool { 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 y)) for { @@ -6346,7 +6311,7 @@ func rewriteValueARM64_OpARM64MADDW_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MNEG_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MNEG_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MNEGW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MNEGW_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MODW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBUloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVBstore_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBstore_20(v *Value) bool { } 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) mem) @@ -9001,11 +8936,12 @@ func rewriteValueARM64_OpARM64MOVBstore_30(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBstoreidx_0(v *Value) bool { 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) mem) @@ -9381,7 +9309,7 @@ func rewriteValueARM64_OpARM64MOVBstoreidx_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVBstorezeroidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDloadidx8_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstoreidx8_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVDstorezeroidx8_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHUloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHUloadidx2_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVHUreg_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHloadidx2_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVHreg_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVHstore_10(v *Value) bool { } 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 [1] idx1) w0 mem) @@ -11901,7 +11807,7 @@ func rewriteValueARM64_OpARM64MOVHstore_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstoreidx_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVHstoreidx_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstoreidx2_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVHstorezeroidx2_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVQstorezero_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWUloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWUloadidx4_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVWUreg_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWloadidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWloadidx4_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool { } 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 [2] idx1) w mem) @@ -13969,7 +13853,7 @@ func rewriteValueARM64_OpARM64MOVWstore_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstoreidx4_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MOVWstorezeroidx4_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MSUB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MSUB_10(v *Value) bool { 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 y)) for { @@ -14933,7 +14803,7 @@ func rewriteValueARM64_OpARM64MSUB_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MSUBW_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64MSUBW_10(v *Value) bool { 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 y)) for { @@ -15404,7 +15260,7 @@ func rewriteValueARM64_OpARM64MSUBW_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MUL_0(v *Value) bool { } 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 x [3])) @@ -15654,7 +15504,7 @@ func rewriteValueARM64_OpARM64MUL_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MULW_0(v *Value) bool { } 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 x [3])) @@ -15919,7 +15763,7 @@ func rewriteValueARM64_OpARM64MULW_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MVN_0(v *Value) bool { } 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))]) @@ -16020,7 +15864,7 @@ func rewriteValueARM64_OpARM64MVNshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64MVNshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64NEG_0(v *Value) bool { } 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))]) @@ -16163,7 +16007,7 @@ func rewriteValueARM64_OpARM64NEGshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64NEGshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64OR_0(v *Value) bool { } 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< 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 (MOVWUloadidx ptr idx mem)) @@ -18297,7 +18129,7 @@ func rewriteValueARM64_OpARM64OR_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORN_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORNshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORNshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORNshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool { 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 [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 ptr0 idx0 mem) @@ -19544,12 +19370,6 @@ func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool { 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 [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 (MOVHUload [i0] {s} p mem)) @@ -20241,7 +20061,7 @@ func rewriteValueARM64_OpARM64ORshiftLL_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64RORWconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64RORconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SBCSflags_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SLL_0(v *Value) bool { } 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)]) @@ -20822,7 +20642,7 @@ func rewriteValueARM64_OpARM64SRAconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64SRLconst_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64STP_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SUB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpARM64SUB_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SUBshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SUBshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TST_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTWconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64TSTshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UBFIZ_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UBFX_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64XOR_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpAbs_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicAdd32Variant_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicAdd64Variant_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicLoad8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpAvg64u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitLen32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitRev16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitRev32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitRev64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBitRev8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBswap32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpBswap64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCeil_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCom64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCondSelect_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConst64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz16NonZero_0(v *Value) bool { 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 x) @@ -23782,7 +23593,7 @@ func rewriteValueARM64_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz32NonZero_0(v *Value) bool { 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 x) @@ -23808,7 +23619,7 @@ func rewriteValueARM64_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCtz8NonZero_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpFMA_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpFloor_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueARM64_OpGetCallerPC_0(v *Value) bool { +func rewriteValueARM64_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -24588,7 +24399,7 @@ func rewriteValueARM64_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueARM64_OpGetCallerSP_0(v *Value) bool { +func rewriteValueARM64_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -24596,7 +24407,7 @@ func rewriteValueARM64_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueARM64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -24604,7 +24415,7 @@ func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpHmul64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpHmul64u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -25460,7 +25271,7 @@ func rewriteValueARM64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMove_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMove_10(v *Value) bool { } 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 @@ func rewriteValueARM64_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul64uhilo_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpNot_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOr64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpPopCount16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpPopCount32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpPopCount64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpRotateLeft32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRotateLeft64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpRound_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRoundToEven_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool { 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 x) @@ -28368,7 +28171,7 @@ func rewriteValueARM64_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueARM64_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSub64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpWB_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpXor64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZero_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZero_10(v *Value) bool { 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 [s-8]) (Zero [s-s%16] ptr mem)) @@ -29371,7 +29161,7 @@ func rewriteValueARM64_OpZero_20(v *Value) bool { } 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 @@ func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool { 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 47adca632e..3058ecb677 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go @@ -8,523 +8,523 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueMIPS_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicLoad8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpAvg32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpBitLen32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCtz32NonZero_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueMIPS_OpGetCallerPC_0(v *Value) bool { +func rewriteValueMIPS_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -1764,7 +1764,7 @@ func rewriteValueMIPS_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueMIPS_OpGetCallerSP_0(v *Value) bool { +func rewriteValueMIPS_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -1772,7 +1772,7 @@ func rewriteValueMIPS_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -1780,7 +1780,7 @@ func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -2454,7 +2454,7 @@ func rewriteValueMIPS_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicStore32_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool { } 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))]) @@ -5492,7 +5488,7 @@ func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMove_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMove_10(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpNot_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpPanicExtend_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRotateLeft32_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRotateLeft64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSignmask_0(v *Value) bool { 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 x) @@ -8213,7 +8201,7 @@ func rewriteValueMIPS_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpWB_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpZero_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpZero_10(v *Value) bool { } 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 @@ func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool { 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 7657eef13d..58d556779f 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go @@ -8,619 +8,619 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueMIPS64_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicAdd64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicCompareAndSwap32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicCompareAndSwap64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicExchange64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicLoad32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicLoad64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicLoad8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicLoadPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicStore64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAtomicStorePtrNoWB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCom64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGetCallerPC_0(v *Value) bool { +func rewriteValueMIPS64_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -1929,7 +1929,7 @@ func rewriteValueMIPS64_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGetCallerSP_0(v *Value) bool { +func rewriteValueMIPS64_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -1937,7 +1937,7 @@ func rewriteValueMIPS64_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -1945,7 +1945,7 @@ func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpHmul64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -2843,7 +2843,7 @@ func rewriteValueMIPS64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd32_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64LoweredAtomicAdd64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore32_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64LoweredAtomicStore64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool { } 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)]) @@ -5926,7 +5922,7 @@ func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMove_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMove_10(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul64uhilo_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpNot_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOr64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpRotateLeft32_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpRotateLeft64_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool { 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 x) @@ -8923,7 +8911,7 @@ func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSub64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpWB_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpXor64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZero_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZero_10(v *Value) bool { } 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 @@ func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool { 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 9ac9cf3aef..12fdcae275 100644 --- a/src/cmd/compile/internal/ssa/rewritePPC64.go +++ b/src/cmd/compile/internal/ssa/rewritePPC64.go @@ -10,721 +10,721 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValuePPC64_OpAbs_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd64carry_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAddr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAndB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicCompareAndSwapRel32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicLoad8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicLoadAcq32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAtomicStoreRel32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpAvg64u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpBitLen32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCeil_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCom16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCom32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCom64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCom8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCondSelect_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpConst16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConst32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConst64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConst8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCopysign_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz32NonZero_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCtz8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEq8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEqB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpFMA_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpFloor_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpGetCallerPC_0(v *Value) bool { +func rewriteValuePPC64_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -2379,7 +2379,7 @@ func rewriteValuePPC64_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpGetCallerSP_0(v *Value) bool { +func rewriteValuePPC64_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -2387,7 +2387,7 @@ func rewriteValuePPC64_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool { +func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -2395,7 +2395,7 @@ func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpHmul64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpHmul64u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLess8U_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMove_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMove_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpMul16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul64uhilo_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpMul8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpNot_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOr16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOr32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOr64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOr8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpOrB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ANDconst_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64FABS_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FCEIL_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FFLOOR_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FGreaterEqual_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64FGreaterThan_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64FLessEqual_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64FLessThan_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FNEG_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FSQRT_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64FTRUNC_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ISEL_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ISEL_10(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ISEL_20(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ISELB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ISELB_10(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64ISELB_20(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MFVSRD_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBZloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVBZreg_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVBreg_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool { 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 x [c]) mem) @@ -8642,15 +8595,6 @@ func rewriteValuePPC64_OpPPC64MOVBstore_10(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVBstore_20(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBstoreidx_0(v *Value) bool { 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 x [c]) mem) @@ -9180,7 +9115,7 @@ func rewriteValuePPC64_OpPPC64MOVBstoreidx_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVDloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVDstoreidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHBRstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHZloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVHZreg_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVHreg_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHstoreidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWBRstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWZloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVWZreg_10(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVWZreg_20(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWloadidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64MOVWreg_10(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWstoreidx_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MTVSRD_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool { } 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 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 (MOVHBRload (MOVDaddr [i0] {s} p) mem) [n1]) @@ -13126,14 +13033,6 @@ func rewriteValuePPC64_OpPPC64OR_10(v *Value) bool { } 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 s6:(SLDconst x7:(MOVBZload [i7] {s} p mem) [56]) o5:(OR s5:(SLDconst x6:(MOVBZload [i6] {s} p mem) [48]) o4:(OR s4:(SLDconst x5:(MOVBZload [i5] {s} p mem) [40]) o3:(OR 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 {s} [i0] p mem) @@ -13613,7 +13512,7 @@ func rewriteValuePPC64_OpPPC64OR_20(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ROTL_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64ROTLW_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpPopCount16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPopCount32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPopCount64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpPopCount8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpRotateLeft32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRotateLeft64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpRound_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool { 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 x) @@ -16756,7 +16655,7 @@ func rewriteValuePPC64_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValuePPC64_OpSub16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSub32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSub64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSub8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpTrunc_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc16to8(v *Value) bool { v_0 := v.Args[0] // match: (Trunc16to8 x) // cond: isSigned(t) @@ -17040,7 +16939,7 @@ func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc32to16(v *Value) bool { v_0 := v.Args[0] // match: (Trunc32to16 x) // cond: isSigned(t) @@ -17064,7 +16963,7 @@ func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc32to8(v *Value) bool { v_0 := v.Args[0] // match: (Trunc32to8 x) // cond: isSigned(t) @@ -17088,7 +16987,7 @@ func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to16(v *Value) bool { v_0 := v.Args[0] // match: (Trunc64to16 x) // cond: isSigned(t) @@ -17112,7 +17011,7 @@ func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to32(v *Value) bool { v_0 := v.Args[0] // match: (Trunc64to32 x) // cond: isSigned(t) @@ -17136,7 +17035,7 @@ func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to8(v *Value) bool { v_0 := v.Args[0] // match: (Trunc64to8 x) // cond: isSigned(t) @@ -17160,7 +17059,7 @@ func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpWB_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpXor16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpXor32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpXor64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpXor8_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZero_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZero_10(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool { 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 5e5c472aab..d7b92c51b6 100644 --- a/src/cmd/compile/internal/ssa/rewriteRISCV64.go +++ b/src/cmd/compile/internal/ssa/rewriteRISCV64.go @@ -9,509 +9,509 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueRISCV64_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpAvg64u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCom64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpConvert_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueRISCV64_OpGetCallerPC_0(v *Value) bool { +func rewriteValueRISCV64_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -1486,7 +1486,7 @@ func rewriteValueRISCV64_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueRISCV64_OpGetCallerSP_0(v *Value) bool { +func rewriteValueRISCV64_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -1494,7 +1494,7 @@ func rewriteValueRISCV64_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueRISCV64_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueRISCV64_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -1502,7 +1502,7 @@ func rewriteValueRISCV64_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpHmul64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpHmul64u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -2278,7 +2278,7 @@ func rewriteValueRISCV64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMove_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpNot_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOr64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64ADD_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64ADDI_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVBUload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVBload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVBstore_0(v *Value) bool { } 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 [c]) @@ -3735,7 +3735,7 @@ func rewriteValueRISCV64_OpRISCV64MOVDconst_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVDload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVHUload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVHload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVHstore_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVWUload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVWload_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRISCV64MOVWstore_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRotateLeft32_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRotateLeft64_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpRsh8x8_0(v *Value) bool { 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 x) @@ -5241,7 +5241,7 @@ func rewriteValueRISCV64_OpSignExt16to32_0(v *Value) bool { 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 x) @@ -5258,7 +5258,7 @@ func rewriteValueRISCV64_OpSignExt16to64_0(v *Value) bool { 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 x) @@ -5275,7 +5275,7 @@ func rewriteValueRISCV64_OpSignExt32to64_0(v *Value) bool { 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 x) @@ -5292,7 +5292,7 @@ func rewriteValueRISCV64_OpSignExt8to16_0(v *Value) bool { 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 x) @@ -5309,7 +5309,7 @@ func rewriteValueRISCV64_OpSignExt8to32_0(v *Value) bool { 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 x) @@ -5326,7 +5326,7 @@ func rewriteValueRISCV64_OpSignExt8to64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueRISCV64_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSub64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc64to16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc64to32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpWB_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpXor64_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueRISCV64_OpZero_0(v *Value) bool { 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 x) @@ -5847,7 +5847,7 @@ func rewriteValueRISCV64_OpZeroExt16to32_0(v *Value) bool { 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 x) @@ -5864,7 +5864,7 @@ func rewriteValueRISCV64_OpZeroExt16to64_0(v *Value) bool { 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 x) @@ -5881,7 +5881,7 @@ func rewriteValueRISCV64_OpZeroExt32to64_0(v *Value) bool { 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 x) @@ -5898,7 +5898,7 @@ func rewriteValueRISCV64_OpZeroExt8to16_0(v *Value) bool { 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 x) @@ -5915,7 +5915,7 @@ func rewriteValueRISCV64_OpZeroExt8to32_0(v *Value) bool { 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 x) diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go index d2b917204b..f396babee3 100644 --- a/src/cmd/compile/internal/ssa/rewriteS390X.go +++ b/src/cmd/compile/internal/ssa/rewriteS390X.go @@ -9,809 +9,809 @@ import "cmd/internal/obj/s390x" 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 @@ func rewriteValueS390X_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicAnd8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicLoad8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicLoadAcq32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicOr8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicStore8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAtomicStoreRel32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpAvg64u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpBswap32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpBswap64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCeil_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCom64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpConstNil_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCtz32NonZero_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpFMA_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpFloor_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueS390X_OpGetCallerPC_0(v *Value) bool { +func rewriteValueS390X_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -2429,7 +2429,7 @@ func rewriteValueS390X_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool { +func rewriteValueS390X_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -2437,7 +2437,7 @@ func rewriteValueS390X_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueS390X_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -2445,7 +2445,7 @@ func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGetG_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpHmul32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpHmul32u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpHmul64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpHmul64u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpITab_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -3574,7 +3574,7 @@ func rewriteValueS390X_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMove_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMove_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul64uhilo_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpNot_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOr64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpPanicBounds_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpPopCount16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpPopCount32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpPopCount64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpPopCount8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpRotateLeft32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRotateLeft64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpRound_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRoundToEven_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XADD_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDC_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDE_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XADDload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XAND_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XANDW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XANDWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XANDload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMP_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XCMPUconst_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XCMPconst_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XCPSDR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFADD_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFNEG_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFNEGS_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool { } 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 (SRDconst [1] (SLDconst [1] x))) @@ -10058,7 +10042,7 @@ func rewriteValueS390X_OpS390XLDGR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XLEDBR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XLGDR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XLOCGR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool { 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 )) // cond: !t.IsSigned() && t.Size() == 1 // result: x @@ -10724,7 +10703,7 @@ func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool { 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 )) // cond: t.IsSigned() && t.Size() == 1 // result: x @@ -11150,7 +11124,7 @@ func rewriteValueS390X_OpS390XMOVBreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool { 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 x:(MOVHloadidx [o] {s} p i mem)) // cond: x.Uses == 1 && clobber(x) // result: @x.Block (MOVHZloadidx [o] {s} p i mem) @@ -13393,7 +13356,7 @@ func rewriteValueS390X_OpS390XMOVHZreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XMOVHreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool { v.AddArg(x) return true } - return false -} -func rewriteValueS390X_OpS390XMOVWZreg_10(v *Value) bool { - v_0 := v.Args[0] - b := v.Block // match: (MOVWZreg x:(MOVWload [o] {s} p mem)) // cond: x.Uses == 1 && clobber(x) // result: @x.Block (MOVWZload [o] {s} p mem) @@ -15068,7 +15017,7 @@ func rewriteValueS390X_OpS390XMOVWZreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWloadidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLDload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XMULLWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XNEG_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XNOT_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XOR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XOR_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XOR_20(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XORW_0(v *Value) bool { } 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 (SLWconst [j1] (MOVHZloadidx [i0] {s} p idx mem)) y) @@ -18953,7 +18872,7 @@ func rewriteValueS390X_OpS390XORW_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XORWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XORconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XORload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XRLL_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XRLLG_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSLD_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSLW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRD_0(v *Value) bool { } 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 x))) @@ -19971,7 +19890,7 @@ func rewriteValueS390X_OpS390XSRDconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSRW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUB_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUBE_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XSUBWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSUBload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XSumBytes2_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XSumBytes4_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XSumBytes8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpS390XXOR_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XXORW_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XXORWload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpS390XXORload_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool { 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 x) @@ -21548,7 +21467,7 @@ func rewriteValueS390X_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueS390X_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSub64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpWB_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpXor64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpZero_0(v *Value) bool { 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 [(s/256)*256]) mem) @@ -22127,7 +22040,7 @@ func rewriteValueS390X_OpZero_10(v *Value) bool { } 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 @@ func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool { 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 5993e9bed1..53d03ad0ca 100644 --- a/src/cmd/compile/internal/ssa/rewriteWasm.go +++ b/src/cmd/compile/internal/ssa/rewriteWasm.go @@ -9,575 +9,575 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValueWasm_OpAbs_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAdd8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAddPtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAddr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAnd16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAnd32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAnd8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpAndB_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCeil_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpClosureCall_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCom16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCom32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCom64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCom8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCondSelect_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConst8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConstBool_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpConstNil_0(v *Value) bool { 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 x mem) @@ -995,7 +995,7 @@ func rewriteValueWasm_OpConvert_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCopysign_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz16NonZero_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz32NonZero_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCtz8NonZero_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Fto32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Fto32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Fto64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Fto64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Fto64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Uto32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32Uto64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32to32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt32to64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Fto32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Fto32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Fto32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Fto64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Fto64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Uto32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64Uto64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64to32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpCvt64to64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv16u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv32u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv64u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpDiv8u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEq8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEqB_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpEqPtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpFloor_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq16U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGeq8U_0(v *Value) bool { return true } } -func rewriteValueWasm_OpGetCallerPC_0(v *Value) bool { +func rewriteValueWasm_OpGetCallerPC(v *Value) bool { // match: (GetCallerPC) // result: (LoweredGetCallerPC) for { @@ -1833,7 +1833,7 @@ func rewriteValueWasm_OpGetCallerPC_0(v *Value) bool { return true } } -func rewriteValueWasm_OpGetCallerSP_0(v *Value) bool { +func rewriteValueWasm_OpGetCallerSP(v *Value) bool { // match: (GetCallerSP) // result: (LoweredGetCallerSP) for { @@ -1841,7 +1841,7 @@ func rewriteValueWasm_OpGetCallerSP_0(v *Value) bool { return true } } -func rewriteValueWasm_OpGetClosurePtr_0(v *Value) bool { +func rewriteValueWasm_OpGetClosurePtr(v *Value) bool { // match: (GetClosurePtr) // result: (LoweredGetClosurePtr) for { @@ -1849,7 +1849,7 @@ func rewriteValueWasm_OpGetClosurePtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater16U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpGreater8U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpInterCall_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpIsInBounds_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpIsNonNil_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpIsSliceInBounds_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq16U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLeq8U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess16U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess32U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLess8U_0(v *Value) bool { 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 ptr mem) @@ -2576,7 +2576,7 @@ func rewriteValueWasm_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpLocalAddr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh16x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh16x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh16x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh16x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh32x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh32x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh32x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh32x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh64x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh64x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh64x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh64x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh8x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh8x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh8x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpLsh8x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod16u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod32u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod64u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMod8u_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMove_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMove_10(v *Value) bool { } 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 @@ func rewriteValueWasm_OpMul16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMul32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMul32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMul64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMul64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpMul8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeg8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeq8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeqB_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNeqPtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNilCheck_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpNot_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOffPtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOr16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOr32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOr64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOr8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpOrB_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpPopCount16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpPopCount32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpPopCount64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpPopCount8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpRotateLeft32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRotateLeft64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpRound32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRound64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRoundToEven_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16Ux16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16Ux32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16Ux64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16Ux8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh16x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32Ux16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32Ux32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32Ux64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32Ux8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh32x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64Ux16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64Ux32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64Ux64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64Ux8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh64x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8Ux16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8Ux32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8Ux64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8Ux8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8x16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8x32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8x64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpRsh8x8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt16to32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt8to16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt8to32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSignExt8to64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSlicemask_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSqrt_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpStaticCall_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpStore_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpSub16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSub32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSub32F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSub64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSub64F_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSub8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpSubPtr_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc16to8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc32to16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc32to8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc64to16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc64to32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpTrunc64to8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpWB_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpWasmF64Add_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmF64Mul_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Add_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64AddConst_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64And_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Eq_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Eqz_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load16S_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load16U_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load32S_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load32U_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load8S_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Load8U_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Mul_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Ne_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Or_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Shl_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64ShrS_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64ShrU_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Store_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Store16_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Store32_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Store8_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpWasmI64Xor_0(v *Value) bool { } 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 @@ func rewriteValueWasm_OpXor16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpXor32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpXor64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpXor8_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZero_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZero_10(v *Value) bool { } 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 @@ func rewriteValueWasm_OpZeroExt16to32_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZeroExt32to64_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZeroExt8to16_0(v *Value) bool { 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 @@ func rewriteValueWasm_OpZeroExt8to32_0(v *Value) bool { 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 1d1dac7866..9393cade62 100644 --- a/src/cmd/compile/internal/ssa/rewritedec.go +++ b/src/cmd/compile/internal/ssa/rewritedec.go @@ -8,31 +8,31 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValuedec_OpComplexImag_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpComplexReal_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpIData_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpITab_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpSliceCap_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpSliceLen_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpSlicePtr_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpStore_0(v *Value) bool { } 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 @@ func rewriteValuedec_OpStringLen_0(v *Value) bool { } 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 28b3ab745b..f518ffcd3a 100644 --- a/src/cmd/compile/internal/ssa/rewritedec64.go +++ b/src/cmd/compile/internal/ssa/rewritedec64.go @@ -8,125 +8,125 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValuedec64_OpAdd64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpAnd64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpArg_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpBitLen64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpBswap64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpCom64_0(v *Value) bool { 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 [c]) @@ -399,7 +399,7 @@ func rewriteValuedec64_OpConst64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpCtz64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpCtz64NonZero_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpEq64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpGeq64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpGeq64U_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpGreater64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpGreater64U_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpInt64Hi_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpInt64Lo_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLeq64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpLeq64U_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpLess64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpLess64U_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpLoad_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh64x16_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh64x32_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh64x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh64x8_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpMul64_0(v *Value) bool { 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 x) @@ -1414,7 +1414,7 @@ func rewriteValuedec64_OpNeg64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpNeq64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpOr64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64x16_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64x32_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh64x8_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpStore_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpSub64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool { } 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 @@ func rewriteValuedec64_OpXor64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool { 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 @@ func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool { 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 0f6d01f22b..9a9e522554 100644 --- a/src/cmd/compile/internal/ssa/rewritedecArgs.go +++ b/src/cmd/compile/internal/ssa/rewritedecArgs.go @@ -6,11 +6,11 @@ package ssa 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 @@ func rewriteValuedecArgs_OpArg_0(v *Value) bool { v.AddArg(v3) return true } - return false -} -func rewriteValuedecArgs_OpArg_10(v *Value) bool { - b := v.Block - fe := b.Func.fe // match: (Arg ) // 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 ea0d92c81b..9d88652d4a 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -9,471 +9,471 @@ import "cmd/compile/internal/types" 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 @@ func rewriteValuegeneric_OpAdd16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAdd32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAdd32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAdd64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAdd64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAdd8_0(v *Value) bool { } 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 x (Const64 [c])) @@ -1618,7 +1618,7 @@ func rewriteValuegeneric_OpAddPtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAnd16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAnd32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAnd64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpAnd8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpArraySelect_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCom16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCom32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCom64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCom8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpConstInterface_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpConstSlice_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpConstString_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpConvert_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt32Fto32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt32Fto64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt32to32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt32to64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt64Fto32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt64Fto64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt64to32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpCvt64to64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv16u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv32u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv64u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpDiv8u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq16_0(v *Value) bool { } 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 n (Rsh16Ux64 (Rsh16x64 n (Const64 [15])) (Const64 [kbar]))) (Const64 [k])) (Const64 [k])) ) // cond: k > 0 && k < 15 && kbar == 16 - k // result: (Eq16 (And16 n (Const16 [int64(1< [0])) @@ -5119,7 +5112,7 @@ func rewriteValuegeneric_OpEq16_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq32_0(v *Value) bool { } 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 (Add32 (Mul32 (Const32 [int64(int32(sdivisible(32,c).m))]) x) (Const32 [int64(int32(sdivisible(32,c).a))]) ) (Const32 [int64(32-sdivisible(32,c).k)]) ) (Const32 [int64(int32(sdivisible(32,c).max))]) ) @@ -6026,7 +6012,7 @@ func rewriteValuegeneric_OpEq32_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq64_0(v *Value) bool { } 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 x (Const64 [y])) (Const64 [y])) // cond: isPowerOfTwo(y) // result: (Neq64 (And64 x (Const64 [y])) (Const64 [0])) @@ -6636,7 +6616,7 @@ func rewriteValuegeneric_OpEq64_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEq8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEqB_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEqInter_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpEqPtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEqPtr_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpEqSlice_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpGeq16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq16U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq32U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq64U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGeq8U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater16U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater32U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater64U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpGreater8U_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpIMake_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpInterCall_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool { 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< 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 (OffPtr [o1] p5) mem) @@ -10067,13 +10025,6 @@ func rewriteValuegeneric_OpLoad_10(v *Value) bool { 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 ptr mem) // cond: t.IsStruct() && t.NumFields() == 1 && fe.CanSSA(t) // result: (StructMake1 (Load (OffPtr [0] ptr) mem)) @@ -10226,7 +10177,7 @@ func rewriteValuegeneric_OpLoad_20(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod16u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod32u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod64u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMod8u_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMove_0(v *Value) bool { 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 [o2] p2) d1 (Store {t3} op3:(OffPtr [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 [o2] dst) d1 (Store {t3} (OffPtr [0] dst) d2 mem)) @@ -13058,14 +13003,6 @@ func rewriteValuegeneric_OpMove_10(v *Value) bool { 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 [o2] p2) d1 (Store {t3} (OffPtr [o3] p3) d2 (Store {t4} (OffPtr [o4] p4) d3 (Store {t5} (OffPtr [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 [o2] dst) d1 (Store {t3} (OffPtr [o3] dst) d2 (Store {t4} (OffPtr [o4] dst) d3 (Store {t5} (OffPtr [o5] dst) d4 (Zero {t1} [n] dst mem))))) @@ -13258,7 +13195,7 @@ func rewriteValuegeneric_OpMove_20(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpMul8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeg8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeq8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeqB_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeqInter_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeqPtr_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNilCheck_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpNot_0(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNot_10(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNot_20(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNot_30(v *Value) bool { 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 @@ func rewriteValuegeneric_OpNot_40(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpOffPtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpOr16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpOr32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpOr64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpOr8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpPhi_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRotateLeft16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRotateLeft32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRotateLeft64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRotateLeft8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRound32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRound64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSelect0_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSelect1_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool { } return false } -func rewriteValuegeneric_OpSliceCap_0(v *Value) bool { +func rewriteValuegeneric_OpSliceCap(v *Value) bool { v_0 := v.Args[0] // match: (SliceCap (SliceMake _ _ (Const64 [c]))) // result: (Const64 [c]) @@ -19614,7 +19530,7 @@ func rewriteValuegeneric_OpSliceCap_0(v *Value) bool { } return false } -func rewriteValuegeneric_OpSliceLen_0(v *Value) bool { +func rewriteValuegeneric_OpSliceLen(v *Value) bool { v_0 := v.Args[0] // match: (SliceLen (SliceMake _ (Const64 [c]) _)) // result: (Const64 [c]) @@ -19670,7 +19586,7 @@ func rewriteValuegeneric_OpSliceLen_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSlicemask_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSqrt_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpStaticCall_0(v *Value) bool { } 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 p2 mem) mem) // cond: isSamePtr(p1, p2) && t2.Size() == sizeof(t1) // result: mem @@ -20165,15 +20083,6 @@ func rewriteValuegeneric_OpStore_0(v *Value) bool { 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 f0 f1) mem) // result: (Store {t.FieldType(1)} (OffPtr [t.FieldOff(1)] dst) f1 (Store {t.FieldType(0)} (OffPtr [0] dst) f0 mem)) for { @@ -20469,13 +20378,6 @@ func rewriteValuegeneric_OpStore_10(v *Value) bool { 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 @@ func rewriteValuegeneric_OpStore_20(v *Value) bool { } return false } -func rewriteValuegeneric_OpStringLen_0(v *Value) bool { +func rewriteValuegeneric_OpStringLen(v *Value) bool { v_0 := v.Args[0] // match: (StringLen (StringMake _ (Const64 [c]))) // result: (Const64 [c]) @@ -20838,7 +20740,7 @@ func rewriteValuegeneric_OpStringLen_0(v *Value) bool { } return false } -func rewriteValuegeneric_OpStringPtr_0(v *Value) bool { +func rewriteValuegeneric_OpStringPtr(v *Value) bool { v_0 := v.Args[0] // match: (StringPtr (StringMake (Addr {s} base) _)) // result: (Addr {s} base) @@ -20862,8 +20764,10 @@ func rewriteValuegeneric_OpStringPtr_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpStructSelect_0(v *Value) bool { 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 ptr mem)) // cond: !fe.CanSSA(t) // result: @x.Block (Load (OffPtr [t.FieldOff(int(i))] ptr) mem) @@ -21035,7 +20933,7 @@ func rewriteValuegeneric_OpStructSelect_10(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub32F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub64F_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpSub8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpXor16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpXor32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpXor64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpXor8_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZero_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool { } 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 @@ func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool { } 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))]) -- 2.48.1