fmt.Fprintln(w, "var _ = objabi.GOROOT // in case not otherwise used")
fmt.Fprintln(w)
+ const chunkSize = 10
// Main rewrite routine is a switch on v.Op.
fmt.Fprintf(w, "func rewriteValue%s(v *Value) bool {\n", arch.name)
fmt.Fprintf(w, "switch v.Op {\n")
for _, op := range ops {
fmt.Fprintf(w, "case %s:\n", op)
- fmt.Fprintf(w, "return rewriteValue%s_%s(v)\n", arch.name, op)
+ fmt.Fprint(w, "return ")
+ for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
+ if chunk > 0 {
+ fmt.Fprint(w, " || ")
+ }
+ fmt.Fprintf(w, "rewriteValue%s_%s_%d(v)", arch.name, op, chunk)
+ }
+ fmt.Fprintln(w)
}
fmt.Fprintf(w, "}\n")
fmt.Fprintf(w, "return false\n")
// Generate a routine per op. Note that we don't make one giant routine
// because it is too big for some compilers.
for _, op := range ops {
- buf := new(bytes.Buffer)
- var canFail bool
- for i, rule := range oprules[op] {
- match, cond, result := rule.parse()
- fmt.Fprintf(buf, "// match: %s\n", match)
- fmt.Fprintf(buf, "// cond: %s\n", cond)
- fmt.Fprintf(buf, "// result: %s\n", result)
-
- canFail = false
- fmt.Fprintf(buf, "for {\n")
- if genMatch(buf, arch, match, rule.loc) {
- canFail = true
+ for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize {
+ buf := new(bytes.Buffer)
+ var canFail bool
+ endchunk := chunk + chunkSize
+ if endchunk > len(oprules[op]) {
+ endchunk = len(oprules[op])
}
+ for i, rule := range oprules[op][chunk:endchunk] {
+ match, cond, result := rule.parse()
+ fmt.Fprintf(buf, "// match: %s\n", match)
+ fmt.Fprintf(buf, "// cond: %s\n", cond)
+ fmt.Fprintf(buf, "// result: %s\n", result)
+
+ canFail = false
+ fmt.Fprintf(buf, "for {\n")
+ if genMatch(buf, arch, match, rule.loc) {
+ canFail = true
+ }
- if cond != "" {
- fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
- canFail = true
+ if cond != "" {
+ fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond)
+ canFail = true
+ }
+ if !canFail && i+chunk != len(oprules[op])-1 {
+ log.Fatalf("unconditional rule %s is followed by other rules", match)
+ }
+
+ genResult(buf, arch, result, rule.loc)
+ if *genLog {
+ fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+ }
+ fmt.Fprintf(buf, "return true\n")
+
+ fmt.Fprintf(buf, "}\n")
}
- if !canFail && i != len(oprules[op])-1 {
- log.Fatalf("unconditional rule %s is followed by other rules", match)
+ if canFail {
+ fmt.Fprintf(buf, "return false\n")
}
- genResult(buf, arch, result, rule.loc)
- if *genLog {
- fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc)
+ body := buf.String()
+ // Do a rough match to predict whether we need b, config, fe, and/or types.
+ // It's not precise--thus the blank assignments--but it's good enough
+ // to avoid generating needless code and doing pointless nil checks.
+ hasb := strings.Contains(body, "b.")
+ hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
+ hasfe := strings.Contains(body, "fe.")
+ hasts := strings.Contains(body, "types.")
+ fmt.Fprintf(w, "func rewriteValue%s_%s_%d(v *Value) bool {\n", arch.name, op, chunk)
+ if hasb || hasconfig || hasfe {
+ fmt.Fprintln(w, "b := v.Block")
+ fmt.Fprintln(w, "_ = b")
}
- fmt.Fprintf(buf, "return true\n")
-
- fmt.Fprintf(buf, "}\n")
- }
- if canFail {
- fmt.Fprintf(buf, "return false\n")
- }
-
- body := buf.String()
- // Do a rough match to predict whether we need b, config, fe, and/or types.
- // It's not precise--thus the blank assignments--but it's good enough
- // to avoid generating needless code and doing pointless nil checks.
- hasb := strings.Contains(body, "b.")
- hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)")
- hasfe := strings.Contains(body, "fe.")
- hasts := strings.Contains(body, "types.")
- fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op)
- if hasb || hasconfig || hasfe {
- fmt.Fprintln(w, "b := v.Block")
- fmt.Fprintln(w, "_ = b")
- }
- if hasconfig {
- fmt.Fprintln(w, "config := b.Func.Config")
- fmt.Fprintln(w, "_ = config")
- }
- if hasfe {
- fmt.Fprintln(w, "fe := b.Func.fe")
- fmt.Fprintln(w, "_ = fe")
- }
- if hasts {
- fmt.Fprintln(w, "types := &b.Func.Config.Types")
- fmt.Fprintln(w, "_ = types")
+ if hasconfig {
+ fmt.Fprintln(w, "config := b.Func.Config")
+ fmt.Fprintln(w, "_ = config")
+ }
+ if hasfe {
+ fmt.Fprintln(w, "fe := b.Func.fe")
+ fmt.Fprintln(w, "_ = fe")
+ }
+ if hasts {
+ fmt.Fprintln(w, "types := &b.Func.Config.Types")
+ fmt.Fprintln(w, "_ = types")
+ }
+ fmt.Fprint(w, body)
+ fmt.Fprintf(w, "}\n")
}
- fmt.Fprint(w, body)
- fmt.Fprintf(w, "}\n")
}
// Generate block rewrite function. There are only a few block types
func rewriteValue386(v *Value) bool {
switch v.Op {
case Op386ADCL:
- return rewriteValue386_Op386ADCL(v)
+ return rewriteValue386_Op386ADCL_0(v)
case Op386ADDL:
- return rewriteValue386_Op386ADDL(v)
+ return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v)
case Op386ADDLcarry:
- return rewriteValue386_Op386ADDLcarry(v)
+ return rewriteValue386_Op386ADDLcarry_0(v)
case Op386ADDLconst:
- return rewriteValue386_Op386ADDLconst(v)
+ return rewriteValue386_Op386ADDLconst_0(v)
case Op386ANDL:
- return rewriteValue386_Op386ANDL(v)
+ return rewriteValue386_Op386ANDL_0(v)
case Op386ANDLconst:
- return rewriteValue386_Op386ANDLconst(v)
+ return rewriteValue386_Op386ANDLconst_0(v)
case Op386CMPB:
- return rewriteValue386_Op386CMPB(v)
+ return rewriteValue386_Op386CMPB_0(v)
case Op386CMPBconst:
- return rewriteValue386_Op386CMPBconst(v)
+ return rewriteValue386_Op386CMPBconst_0(v)
case Op386CMPL:
- return rewriteValue386_Op386CMPL(v)
+ return rewriteValue386_Op386CMPL_0(v)
case Op386CMPLconst:
- return rewriteValue386_Op386CMPLconst(v)
+ return rewriteValue386_Op386CMPLconst_0(v)
case Op386CMPW:
- return rewriteValue386_Op386CMPW(v)
+ return rewriteValue386_Op386CMPW_0(v)
case Op386CMPWconst:
- return rewriteValue386_Op386CMPWconst(v)
+ return rewriteValue386_Op386CMPWconst_0(v)
case Op386LEAL:
- return rewriteValue386_Op386LEAL(v)
+ return rewriteValue386_Op386LEAL_0(v)
case Op386LEAL1:
- return rewriteValue386_Op386LEAL1(v)
+ return rewriteValue386_Op386LEAL1_0(v)
case Op386LEAL2:
- return rewriteValue386_Op386LEAL2(v)
+ return rewriteValue386_Op386LEAL2_0(v)
case Op386LEAL4:
- return rewriteValue386_Op386LEAL4(v)
+ return rewriteValue386_Op386LEAL4_0(v)
case Op386LEAL8:
- return rewriteValue386_Op386LEAL8(v)
+ return rewriteValue386_Op386LEAL8_0(v)
case Op386MOVBLSX:
- return rewriteValue386_Op386MOVBLSX(v)
+ return rewriteValue386_Op386MOVBLSX_0(v)
case Op386MOVBLSXload:
- return rewriteValue386_Op386MOVBLSXload(v)
+ return rewriteValue386_Op386MOVBLSXload_0(v)
case Op386MOVBLZX:
- return rewriteValue386_Op386MOVBLZX(v)
+ return rewriteValue386_Op386MOVBLZX_0(v)
case Op386MOVBload:
- return rewriteValue386_Op386MOVBload(v)
+ return rewriteValue386_Op386MOVBload_0(v)
case Op386MOVBloadidx1:
- return rewriteValue386_Op386MOVBloadidx1(v)
+ return rewriteValue386_Op386MOVBloadidx1_0(v)
case Op386MOVBstore:
- return rewriteValue386_Op386MOVBstore(v)
+ return rewriteValue386_Op386MOVBstore_0(v)
case Op386MOVBstoreconst:
- return rewriteValue386_Op386MOVBstoreconst(v)
+ return rewriteValue386_Op386MOVBstoreconst_0(v)
case Op386MOVBstoreconstidx1:
- return rewriteValue386_Op386MOVBstoreconstidx1(v)
+ return rewriteValue386_Op386MOVBstoreconstidx1_0(v)
case Op386MOVBstoreidx1:
- return rewriteValue386_Op386MOVBstoreidx1(v)
+ return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v)
case Op386MOVLload:
- return rewriteValue386_Op386MOVLload(v)
+ return rewriteValue386_Op386MOVLload_0(v)
case Op386MOVLloadidx1:
- return rewriteValue386_Op386MOVLloadidx1(v)
+ return rewriteValue386_Op386MOVLloadidx1_0(v)
case Op386MOVLloadidx4:
- return rewriteValue386_Op386MOVLloadidx4(v)
+ return rewriteValue386_Op386MOVLloadidx4_0(v)
case Op386MOVLstore:
- return rewriteValue386_Op386MOVLstore(v)
+ return rewriteValue386_Op386MOVLstore_0(v)
case Op386MOVLstoreconst:
- return rewriteValue386_Op386MOVLstoreconst(v)
+ return rewriteValue386_Op386MOVLstoreconst_0(v)
case Op386MOVLstoreconstidx1:
- return rewriteValue386_Op386MOVLstoreconstidx1(v)
+ return rewriteValue386_Op386MOVLstoreconstidx1_0(v)
case Op386MOVLstoreconstidx4:
- return rewriteValue386_Op386MOVLstoreconstidx4(v)
+ return rewriteValue386_Op386MOVLstoreconstidx4_0(v)
case Op386MOVLstoreidx1:
- return rewriteValue386_Op386MOVLstoreidx1(v)
+ return rewriteValue386_Op386MOVLstoreidx1_0(v)
case Op386MOVLstoreidx4:
- return rewriteValue386_Op386MOVLstoreidx4(v)
+ return rewriteValue386_Op386MOVLstoreidx4_0(v)
case Op386MOVSDconst:
- return rewriteValue386_Op386MOVSDconst(v)
+ return rewriteValue386_Op386MOVSDconst_0(v)
case Op386MOVSDload:
- return rewriteValue386_Op386MOVSDload(v)
+ return rewriteValue386_Op386MOVSDload_0(v)
case Op386MOVSDloadidx1:
- return rewriteValue386_Op386MOVSDloadidx1(v)
+ return rewriteValue386_Op386MOVSDloadidx1_0(v)
case Op386MOVSDloadidx8:
- return rewriteValue386_Op386MOVSDloadidx8(v)
+ return rewriteValue386_Op386MOVSDloadidx8_0(v)
case Op386MOVSDstore:
- return rewriteValue386_Op386MOVSDstore(v)
+ return rewriteValue386_Op386MOVSDstore_0(v)
case Op386MOVSDstoreidx1:
- return rewriteValue386_Op386MOVSDstoreidx1(v)
+ return rewriteValue386_Op386MOVSDstoreidx1_0(v)
case Op386MOVSDstoreidx8:
- return rewriteValue386_Op386MOVSDstoreidx8(v)
+ return rewriteValue386_Op386MOVSDstoreidx8_0(v)
case Op386MOVSSconst:
- return rewriteValue386_Op386MOVSSconst(v)
+ return rewriteValue386_Op386MOVSSconst_0(v)
case Op386MOVSSload:
- return rewriteValue386_Op386MOVSSload(v)
+ return rewriteValue386_Op386MOVSSload_0(v)
case Op386MOVSSloadidx1:
- return rewriteValue386_Op386MOVSSloadidx1(v)
+ return rewriteValue386_Op386MOVSSloadidx1_0(v)
case Op386MOVSSloadidx4:
- return rewriteValue386_Op386MOVSSloadidx4(v)
+ return rewriteValue386_Op386MOVSSloadidx4_0(v)
case Op386MOVSSstore:
- return rewriteValue386_Op386MOVSSstore(v)
+ return rewriteValue386_Op386MOVSSstore_0(v)
case Op386MOVSSstoreidx1:
- return rewriteValue386_Op386MOVSSstoreidx1(v)
+ return rewriteValue386_Op386MOVSSstoreidx1_0(v)
case Op386MOVSSstoreidx4:
- return rewriteValue386_Op386MOVSSstoreidx4(v)
+ return rewriteValue386_Op386MOVSSstoreidx4_0(v)
case Op386MOVWLSX:
- return rewriteValue386_Op386MOVWLSX(v)
+ return rewriteValue386_Op386MOVWLSX_0(v)
case Op386MOVWLSXload:
- return rewriteValue386_Op386MOVWLSXload(v)
+ return rewriteValue386_Op386MOVWLSXload_0(v)
case Op386MOVWLZX:
- return rewriteValue386_Op386MOVWLZX(v)
+ return rewriteValue386_Op386MOVWLZX_0(v)
case Op386MOVWload:
- return rewriteValue386_Op386MOVWload(v)
+ return rewriteValue386_Op386MOVWload_0(v)
case Op386MOVWloadidx1:
- return rewriteValue386_Op386MOVWloadidx1(v)
+ return rewriteValue386_Op386MOVWloadidx1_0(v)
case Op386MOVWloadidx2:
- return rewriteValue386_Op386MOVWloadidx2(v)
+ return rewriteValue386_Op386MOVWloadidx2_0(v)
case Op386MOVWstore:
- return rewriteValue386_Op386MOVWstore(v)
+ return rewriteValue386_Op386MOVWstore_0(v)
case Op386MOVWstoreconst:
- return rewriteValue386_Op386MOVWstoreconst(v)
+ return rewriteValue386_Op386MOVWstoreconst_0(v)
case Op386MOVWstoreconstidx1:
- return rewriteValue386_Op386MOVWstoreconstidx1(v)
+ return rewriteValue386_Op386MOVWstoreconstidx1_0(v)
case Op386MOVWstoreconstidx2:
- return rewriteValue386_Op386MOVWstoreconstidx2(v)
+ return rewriteValue386_Op386MOVWstoreconstidx2_0(v)
case Op386MOVWstoreidx1:
- return rewriteValue386_Op386MOVWstoreidx1(v)
+ return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v)
case Op386MOVWstoreidx2:
- return rewriteValue386_Op386MOVWstoreidx2(v)
+ return rewriteValue386_Op386MOVWstoreidx2_0(v)
case Op386MULL:
- return rewriteValue386_Op386MULL(v)
+ return rewriteValue386_Op386MULL_0(v)
case Op386MULLconst:
- return rewriteValue386_Op386MULLconst(v)
+ return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v)
case Op386NEGL:
- return rewriteValue386_Op386NEGL(v)
+ return rewriteValue386_Op386NEGL_0(v)
case Op386NOTL:
- return rewriteValue386_Op386NOTL(v)
+ return rewriteValue386_Op386NOTL_0(v)
case Op386ORL:
- return rewriteValue386_Op386ORL(v)
+ return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v)
case Op386ORLconst:
- return rewriteValue386_Op386ORLconst(v)
+ return rewriteValue386_Op386ORLconst_0(v)
case Op386ROLBconst:
- return rewriteValue386_Op386ROLBconst(v)
+ return rewriteValue386_Op386ROLBconst_0(v)
case Op386ROLLconst:
- return rewriteValue386_Op386ROLLconst(v)
+ return rewriteValue386_Op386ROLLconst_0(v)
case Op386ROLWconst:
- return rewriteValue386_Op386ROLWconst(v)
+ return rewriteValue386_Op386ROLWconst_0(v)
case Op386SARB:
- return rewriteValue386_Op386SARB(v)
+ return rewriteValue386_Op386SARB_0(v)
case Op386SARBconst:
- return rewriteValue386_Op386SARBconst(v)
+ return rewriteValue386_Op386SARBconst_0(v)
case Op386SARL:
- return rewriteValue386_Op386SARL(v)
+ return rewriteValue386_Op386SARL_0(v)
case Op386SARLconst:
- return rewriteValue386_Op386SARLconst(v)
+ return rewriteValue386_Op386SARLconst_0(v)
case Op386SARW:
- return rewriteValue386_Op386SARW(v)
+ return rewriteValue386_Op386SARW_0(v)
case Op386SARWconst:
- return rewriteValue386_Op386SARWconst(v)
+ return rewriteValue386_Op386SARWconst_0(v)
case Op386SBBL:
- return rewriteValue386_Op386SBBL(v)
+ return rewriteValue386_Op386SBBL_0(v)
case Op386SBBLcarrymask:
- return rewriteValue386_Op386SBBLcarrymask(v)
+ return rewriteValue386_Op386SBBLcarrymask_0(v)
case Op386SETA:
- return rewriteValue386_Op386SETA(v)
+ return rewriteValue386_Op386SETA_0(v)
case Op386SETAE:
- return rewriteValue386_Op386SETAE(v)
+ return rewriteValue386_Op386SETAE_0(v)
case Op386SETB:
- return rewriteValue386_Op386SETB(v)
+ return rewriteValue386_Op386SETB_0(v)
case Op386SETBE:
- return rewriteValue386_Op386SETBE(v)
+ return rewriteValue386_Op386SETBE_0(v)
case Op386SETEQ:
- return rewriteValue386_Op386SETEQ(v)
+ return rewriteValue386_Op386SETEQ_0(v)
case Op386SETG:
- return rewriteValue386_Op386SETG(v)
+ return rewriteValue386_Op386SETG_0(v)
case Op386SETGE:
- return rewriteValue386_Op386SETGE(v)
+ return rewriteValue386_Op386SETGE_0(v)
case Op386SETL:
- return rewriteValue386_Op386SETL(v)
+ return rewriteValue386_Op386SETL_0(v)
case Op386SETLE:
- return rewriteValue386_Op386SETLE(v)
+ return rewriteValue386_Op386SETLE_0(v)
case Op386SETNE:
- return rewriteValue386_Op386SETNE(v)
+ return rewriteValue386_Op386SETNE_0(v)
case Op386SHLL:
- return rewriteValue386_Op386SHLL(v)
+ return rewriteValue386_Op386SHLL_0(v)
case Op386SHLLconst:
- return rewriteValue386_Op386SHLLconst(v)
+ return rewriteValue386_Op386SHLLconst_0(v)
case Op386SHRB:
- return rewriteValue386_Op386SHRB(v)
+ return rewriteValue386_Op386SHRB_0(v)
case Op386SHRBconst:
- return rewriteValue386_Op386SHRBconst(v)
+ return rewriteValue386_Op386SHRBconst_0(v)
case Op386SHRL:
- return rewriteValue386_Op386SHRL(v)
+ return rewriteValue386_Op386SHRL_0(v)
case Op386SHRLconst:
- return rewriteValue386_Op386SHRLconst(v)
+ return rewriteValue386_Op386SHRLconst_0(v)
case Op386SHRW:
- return rewriteValue386_Op386SHRW(v)
+ return rewriteValue386_Op386SHRW_0(v)
case Op386SHRWconst:
- return rewriteValue386_Op386SHRWconst(v)
+ return rewriteValue386_Op386SHRWconst_0(v)
case Op386SUBL:
- return rewriteValue386_Op386SUBL(v)
+ return rewriteValue386_Op386SUBL_0(v)
case Op386SUBLcarry:
- return rewriteValue386_Op386SUBLcarry(v)
+ return rewriteValue386_Op386SUBLcarry_0(v)
case Op386SUBLconst:
- return rewriteValue386_Op386SUBLconst(v)
+ return rewriteValue386_Op386SUBLconst_0(v)
case Op386XORL:
- return rewriteValue386_Op386XORL(v)
+ return rewriteValue386_Op386XORL_0(v)
case Op386XORLconst:
- return rewriteValue386_Op386XORLconst(v)
+ return rewriteValue386_Op386XORLconst_0(v)
case OpAdd16:
- return rewriteValue386_OpAdd16(v)
+ return rewriteValue386_OpAdd16_0(v)
case OpAdd32:
- return rewriteValue386_OpAdd32(v)
+ return rewriteValue386_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValue386_OpAdd32F(v)
+ return rewriteValue386_OpAdd32F_0(v)
case OpAdd32carry:
- return rewriteValue386_OpAdd32carry(v)
+ return rewriteValue386_OpAdd32carry_0(v)
case OpAdd32withcarry:
- return rewriteValue386_OpAdd32withcarry(v)
+ return rewriteValue386_OpAdd32withcarry_0(v)
case OpAdd64F:
- return rewriteValue386_OpAdd64F(v)
+ return rewriteValue386_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValue386_OpAdd8(v)
+ return rewriteValue386_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValue386_OpAddPtr(v)
+ return rewriteValue386_OpAddPtr_0(v)
case OpAddr:
- return rewriteValue386_OpAddr(v)
+ return rewriteValue386_OpAddr_0(v)
case OpAnd16:
- return rewriteValue386_OpAnd16(v)
+ return rewriteValue386_OpAnd16_0(v)
case OpAnd32:
- return rewriteValue386_OpAnd32(v)
+ return rewriteValue386_OpAnd32_0(v)
case OpAnd8:
- return rewriteValue386_OpAnd8(v)
+ return rewriteValue386_OpAnd8_0(v)
case OpAndB:
- return rewriteValue386_OpAndB(v)
+ return rewriteValue386_OpAndB_0(v)
case OpAvg32u:
- return rewriteValue386_OpAvg32u(v)
+ return rewriteValue386_OpAvg32u_0(v)
case OpBswap32:
- return rewriteValue386_OpBswap32(v)
+ return rewriteValue386_OpBswap32_0(v)
case OpClosureCall:
- return rewriteValue386_OpClosureCall(v)
+ return rewriteValue386_OpClosureCall_0(v)
case OpCom16:
- return rewriteValue386_OpCom16(v)
+ return rewriteValue386_OpCom16_0(v)
case OpCom32:
- return rewriteValue386_OpCom32(v)
+ return rewriteValue386_OpCom32_0(v)
case OpCom8:
- return rewriteValue386_OpCom8(v)
+ return rewriteValue386_OpCom8_0(v)
case OpConst16:
- return rewriteValue386_OpConst16(v)
+ return rewriteValue386_OpConst16_0(v)
case OpConst32:
- return rewriteValue386_OpConst32(v)
+ return rewriteValue386_OpConst32_0(v)
case OpConst32F:
- return rewriteValue386_OpConst32F(v)
+ return rewriteValue386_OpConst32F_0(v)
case OpConst64F:
- return rewriteValue386_OpConst64F(v)
+ return rewriteValue386_OpConst64F_0(v)
case OpConst8:
- return rewriteValue386_OpConst8(v)
+ return rewriteValue386_OpConst8_0(v)
case OpConstBool:
- return rewriteValue386_OpConstBool(v)
+ return rewriteValue386_OpConstBool_0(v)
case OpConstNil:
- return rewriteValue386_OpConstNil(v)
+ return rewriteValue386_OpConstNil_0(v)
case OpConvert:
- return rewriteValue386_OpConvert(v)
+ return rewriteValue386_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValue386_OpCvt32Fto32(v)
+ return rewriteValue386_OpCvt32Fto32_0(v)
case OpCvt32Fto64F:
- return rewriteValue386_OpCvt32Fto64F(v)
+ return rewriteValue386_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValue386_OpCvt32to32F(v)
+ return rewriteValue386_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValue386_OpCvt32to64F(v)
+ return rewriteValue386_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValue386_OpCvt64Fto32(v)
+ return rewriteValue386_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValue386_OpCvt64Fto32F(v)
+ return rewriteValue386_OpCvt64Fto32F_0(v)
case OpDiv16:
- return rewriteValue386_OpDiv16(v)
+ return rewriteValue386_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValue386_OpDiv16u(v)
+ return rewriteValue386_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValue386_OpDiv32(v)
+ return rewriteValue386_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValue386_OpDiv32F(v)
+ return rewriteValue386_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValue386_OpDiv32u(v)
+ return rewriteValue386_OpDiv32u_0(v)
case OpDiv64F:
- return rewriteValue386_OpDiv64F(v)
+ return rewriteValue386_OpDiv64F_0(v)
case OpDiv8:
- return rewriteValue386_OpDiv8(v)
+ return rewriteValue386_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValue386_OpDiv8u(v)
+ return rewriteValue386_OpDiv8u_0(v)
case OpEq16:
- return rewriteValue386_OpEq16(v)
+ return rewriteValue386_OpEq16_0(v)
case OpEq32:
- return rewriteValue386_OpEq32(v)
+ return rewriteValue386_OpEq32_0(v)
case OpEq32F:
- return rewriteValue386_OpEq32F(v)
+ return rewriteValue386_OpEq32F_0(v)
case OpEq64F:
- return rewriteValue386_OpEq64F(v)
+ return rewriteValue386_OpEq64F_0(v)
case OpEq8:
- return rewriteValue386_OpEq8(v)
+ return rewriteValue386_OpEq8_0(v)
case OpEqB:
- return rewriteValue386_OpEqB(v)
+ return rewriteValue386_OpEqB_0(v)
case OpEqPtr:
- return rewriteValue386_OpEqPtr(v)
+ return rewriteValue386_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValue386_OpGeq16(v)
+ return rewriteValue386_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValue386_OpGeq16U(v)
+ return rewriteValue386_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValue386_OpGeq32(v)
+ return rewriteValue386_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValue386_OpGeq32F(v)
+ return rewriteValue386_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValue386_OpGeq32U(v)
+ return rewriteValue386_OpGeq32U_0(v)
case OpGeq64F:
- return rewriteValue386_OpGeq64F(v)
+ return rewriteValue386_OpGeq64F_0(v)
case OpGeq8:
- return rewriteValue386_OpGeq8(v)
+ return rewriteValue386_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValue386_OpGeq8U(v)
+ return rewriteValue386_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValue386_OpGetClosurePtr(v)
+ return rewriteValue386_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValue386_OpGetG(v)
+ return rewriteValue386_OpGetG_0(v)
case OpGreater16:
- return rewriteValue386_OpGreater16(v)
+ return rewriteValue386_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValue386_OpGreater16U(v)
+ return rewriteValue386_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValue386_OpGreater32(v)
+ return rewriteValue386_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValue386_OpGreater32F(v)
+ return rewriteValue386_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValue386_OpGreater32U(v)
+ return rewriteValue386_OpGreater32U_0(v)
case OpGreater64F:
- return rewriteValue386_OpGreater64F(v)
+ return rewriteValue386_OpGreater64F_0(v)
case OpGreater8:
- return rewriteValue386_OpGreater8(v)
+ return rewriteValue386_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValue386_OpGreater8U(v)
+ return rewriteValue386_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValue386_OpHmul32(v)
+ return rewriteValue386_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValue386_OpHmul32u(v)
+ return rewriteValue386_OpHmul32u_0(v)
case OpInterCall:
- return rewriteValue386_OpInterCall(v)
+ return rewriteValue386_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValue386_OpIsInBounds(v)
+ return rewriteValue386_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValue386_OpIsNonNil(v)
+ return rewriteValue386_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValue386_OpIsSliceInBounds(v)
+ return rewriteValue386_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValue386_OpLeq16(v)
+ return rewriteValue386_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValue386_OpLeq16U(v)
+ return rewriteValue386_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValue386_OpLeq32(v)
+ return rewriteValue386_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValue386_OpLeq32F(v)
+ return rewriteValue386_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValue386_OpLeq32U(v)
+ return rewriteValue386_OpLeq32U_0(v)
case OpLeq64F:
- return rewriteValue386_OpLeq64F(v)
+ return rewriteValue386_OpLeq64F_0(v)
case OpLeq8:
- return rewriteValue386_OpLeq8(v)
+ return rewriteValue386_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValue386_OpLeq8U(v)
+ return rewriteValue386_OpLeq8U_0(v)
case OpLess16:
- return rewriteValue386_OpLess16(v)
+ return rewriteValue386_OpLess16_0(v)
case OpLess16U:
- return rewriteValue386_OpLess16U(v)
+ return rewriteValue386_OpLess16U_0(v)
case OpLess32:
- return rewriteValue386_OpLess32(v)
+ return rewriteValue386_OpLess32_0(v)
case OpLess32F:
- return rewriteValue386_OpLess32F(v)
+ return rewriteValue386_OpLess32F_0(v)
case OpLess32U:
- return rewriteValue386_OpLess32U(v)
+ return rewriteValue386_OpLess32U_0(v)
case OpLess64F:
- return rewriteValue386_OpLess64F(v)
+ return rewriteValue386_OpLess64F_0(v)
case OpLess8:
- return rewriteValue386_OpLess8(v)
+ return rewriteValue386_OpLess8_0(v)
case OpLess8U:
- return rewriteValue386_OpLess8U(v)
+ return rewriteValue386_OpLess8U_0(v)
case OpLoad:
- return rewriteValue386_OpLoad(v)
+ return rewriteValue386_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValue386_OpLsh16x16(v)
+ return rewriteValue386_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValue386_OpLsh16x32(v)
+ return rewriteValue386_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValue386_OpLsh16x64(v)
+ return rewriteValue386_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValue386_OpLsh16x8(v)
+ return rewriteValue386_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValue386_OpLsh32x16(v)
+ return rewriteValue386_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValue386_OpLsh32x32(v)
+ return rewriteValue386_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValue386_OpLsh32x64(v)
+ return rewriteValue386_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValue386_OpLsh32x8(v)
+ return rewriteValue386_OpLsh32x8_0(v)
case OpLsh8x16:
- return rewriteValue386_OpLsh8x16(v)
+ return rewriteValue386_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValue386_OpLsh8x32(v)
+ return rewriteValue386_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValue386_OpLsh8x64(v)
+ return rewriteValue386_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValue386_OpLsh8x8(v)
+ return rewriteValue386_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValue386_OpMod16(v)
+ return rewriteValue386_OpMod16_0(v)
case OpMod16u:
- return rewriteValue386_OpMod16u(v)
+ return rewriteValue386_OpMod16u_0(v)
case OpMod32:
- return rewriteValue386_OpMod32(v)
+ return rewriteValue386_OpMod32_0(v)
case OpMod32u:
- return rewriteValue386_OpMod32u(v)
+ return rewriteValue386_OpMod32u_0(v)
case OpMod8:
- return rewriteValue386_OpMod8(v)
+ return rewriteValue386_OpMod8_0(v)
case OpMod8u:
- return rewriteValue386_OpMod8u(v)
+ return rewriteValue386_OpMod8u_0(v)
case OpMove:
- return rewriteValue386_OpMove(v)
+ return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v)
case OpMul16:
- return rewriteValue386_OpMul16(v)
+ return rewriteValue386_OpMul16_0(v)
case OpMul32:
- return rewriteValue386_OpMul32(v)
+ return rewriteValue386_OpMul32_0(v)
case OpMul32F:
- return rewriteValue386_OpMul32F(v)
+ return rewriteValue386_OpMul32F_0(v)
case OpMul32uhilo:
- return rewriteValue386_OpMul32uhilo(v)
+ return rewriteValue386_OpMul32uhilo_0(v)
case OpMul64F:
- return rewriteValue386_OpMul64F(v)
+ return rewriteValue386_OpMul64F_0(v)
case OpMul8:
- return rewriteValue386_OpMul8(v)
+ return rewriteValue386_OpMul8_0(v)
case OpNeg16:
- return rewriteValue386_OpNeg16(v)
+ return rewriteValue386_OpNeg16_0(v)
case OpNeg32:
- return rewriteValue386_OpNeg32(v)
+ return rewriteValue386_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValue386_OpNeg32F(v)
+ return rewriteValue386_OpNeg32F_0(v)
case OpNeg64F:
- return rewriteValue386_OpNeg64F(v)
+ return rewriteValue386_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValue386_OpNeg8(v)
+ return rewriteValue386_OpNeg8_0(v)
case OpNeq16:
- return rewriteValue386_OpNeq16(v)
+ return rewriteValue386_OpNeq16_0(v)
case OpNeq32:
- return rewriteValue386_OpNeq32(v)
+ return rewriteValue386_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValue386_OpNeq32F(v)
+ return rewriteValue386_OpNeq32F_0(v)
case OpNeq64F:
- return rewriteValue386_OpNeq64F(v)
+ return rewriteValue386_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValue386_OpNeq8(v)
+ return rewriteValue386_OpNeq8_0(v)
case OpNeqB:
- return rewriteValue386_OpNeqB(v)
+ return rewriteValue386_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValue386_OpNeqPtr(v)
+ return rewriteValue386_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValue386_OpNilCheck(v)
+ return rewriteValue386_OpNilCheck_0(v)
case OpNot:
- return rewriteValue386_OpNot(v)
+ return rewriteValue386_OpNot_0(v)
case OpOffPtr:
- return rewriteValue386_OpOffPtr(v)
+ return rewriteValue386_OpOffPtr_0(v)
case OpOr16:
- return rewriteValue386_OpOr16(v)
+ return rewriteValue386_OpOr16_0(v)
case OpOr32:
- return rewriteValue386_OpOr32(v)
+ return rewriteValue386_OpOr32_0(v)
case OpOr8:
- return rewriteValue386_OpOr8(v)
+ return rewriteValue386_OpOr8_0(v)
case OpOrB:
- return rewriteValue386_OpOrB(v)
+ return rewriteValue386_OpOrB_0(v)
case OpRound32F:
- return rewriteValue386_OpRound32F(v)
+ return rewriteValue386_OpRound32F_0(v)
case OpRound64F:
- return rewriteValue386_OpRound64F(v)
+ return rewriteValue386_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValue386_OpRsh16Ux16(v)
+ return rewriteValue386_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValue386_OpRsh16Ux32(v)
+ return rewriteValue386_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValue386_OpRsh16Ux64(v)
+ return rewriteValue386_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValue386_OpRsh16Ux8(v)
+ return rewriteValue386_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValue386_OpRsh16x16(v)
+ return rewriteValue386_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValue386_OpRsh16x32(v)
+ return rewriteValue386_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValue386_OpRsh16x64(v)
+ return rewriteValue386_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValue386_OpRsh16x8(v)
+ return rewriteValue386_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValue386_OpRsh32Ux16(v)
+ return rewriteValue386_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValue386_OpRsh32Ux32(v)
+ return rewriteValue386_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValue386_OpRsh32Ux64(v)
+ return rewriteValue386_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValue386_OpRsh32Ux8(v)
+ return rewriteValue386_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValue386_OpRsh32x16(v)
+ return rewriteValue386_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValue386_OpRsh32x32(v)
+ return rewriteValue386_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValue386_OpRsh32x64(v)
+ return rewriteValue386_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValue386_OpRsh32x8(v)
+ return rewriteValue386_OpRsh32x8_0(v)
case OpRsh8Ux16:
- return rewriteValue386_OpRsh8Ux16(v)
+ return rewriteValue386_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValue386_OpRsh8Ux32(v)
+ return rewriteValue386_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValue386_OpRsh8Ux64(v)
+ return rewriteValue386_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValue386_OpRsh8Ux8(v)
+ return rewriteValue386_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValue386_OpRsh8x16(v)
+ return rewriteValue386_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValue386_OpRsh8x32(v)
+ return rewriteValue386_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValue386_OpRsh8x64(v)
+ return rewriteValue386_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValue386_OpRsh8x8(v)
+ return rewriteValue386_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValue386_OpSignExt16to32(v)
+ return rewriteValue386_OpSignExt16to32_0(v)
case OpSignExt8to16:
- return rewriteValue386_OpSignExt8to16(v)
+ return rewriteValue386_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValue386_OpSignExt8to32(v)
+ return rewriteValue386_OpSignExt8to32_0(v)
case OpSignmask:
- return rewriteValue386_OpSignmask(v)
+ return rewriteValue386_OpSignmask_0(v)
case OpSlicemask:
- return rewriteValue386_OpSlicemask(v)
+ return rewriteValue386_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValue386_OpSqrt(v)
+ return rewriteValue386_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValue386_OpStaticCall(v)
+ return rewriteValue386_OpStaticCall_0(v)
case OpStore:
- return rewriteValue386_OpStore(v)
+ return rewriteValue386_OpStore_0(v)
case OpSub16:
- return rewriteValue386_OpSub16(v)
+ return rewriteValue386_OpSub16_0(v)
case OpSub32:
- return rewriteValue386_OpSub32(v)
+ return rewriteValue386_OpSub32_0(v)
case OpSub32F:
- return rewriteValue386_OpSub32F(v)
+ return rewriteValue386_OpSub32F_0(v)
case OpSub32carry:
- return rewriteValue386_OpSub32carry(v)
+ return rewriteValue386_OpSub32carry_0(v)
case OpSub32withcarry:
- return rewriteValue386_OpSub32withcarry(v)
+ return rewriteValue386_OpSub32withcarry_0(v)
case OpSub64F:
- return rewriteValue386_OpSub64F(v)
+ return rewriteValue386_OpSub64F_0(v)
case OpSub8:
- return rewriteValue386_OpSub8(v)
+ return rewriteValue386_OpSub8_0(v)
case OpSubPtr:
- return rewriteValue386_OpSubPtr(v)
+ return rewriteValue386_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValue386_OpTrunc16to8(v)
+ return rewriteValue386_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValue386_OpTrunc32to16(v)
+ return rewriteValue386_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValue386_OpTrunc32to8(v)
+ return rewriteValue386_OpTrunc32to8_0(v)
case OpXor16:
- return rewriteValue386_OpXor16(v)
+ return rewriteValue386_OpXor16_0(v)
case OpXor32:
- return rewriteValue386_OpXor32(v)
+ return rewriteValue386_OpXor32_0(v)
case OpXor8:
- return rewriteValue386_OpXor8(v)
+ return rewriteValue386_OpXor8_0(v)
case OpZero:
- return rewriteValue386_OpZero(v)
+ return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValue386_OpZeroExt16to32(v)
+ return rewriteValue386_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
- return rewriteValue386_OpZeroExt8to16(v)
+ return rewriteValue386_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValue386_OpZeroExt8to32(v)
+ return rewriteValue386_OpZeroExt8to32_0(v)
case OpZeromask:
- return rewriteValue386_OpZeromask(v)
+ return rewriteValue386_OpZeromask_0(v)
}
return false
}
-func rewriteValue386_Op386ADCL(v *Value) bool {
+func rewriteValue386_Op386ADCL_0(v *Value) bool {
// match: (ADCL x (MOVLconst [c]) f)
// cond:
// result: (ADCLconst [c] x f)
}
return false
}
-func rewriteValue386_Op386ADDL(v *Value) bool {
+func rewriteValue386_Op386ADDL_0(v *Value) bool {
// match: (ADDL x (MOVLconst [c]))
// cond:
// result: (ADDLconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValue386_Op386ADDL_10(v *Value) bool {
// match: (ADDL x (SHLLconst [2] y))
// cond:
// result: (LEAL4 x y)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValue386_Op386ADDL_20(v *Value) bool {
// match: (ADDL (ADDLconst [c] x) y)
// cond:
// result: (LEAL1 [c] x y)
}
return false
}
-func rewriteValue386_Op386ADDLcarry(v *Value) bool {
+func rewriteValue386_Op386ADDLcarry_0(v *Value) bool {
// match: (ADDLcarry x (MOVLconst [c]))
// cond:
// result: (ADDLconstcarry [c] x)
}
return false
}
-func rewriteValue386_Op386ADDLconst(v *Value) bool {
+func rewriteValue386_Op386ADDLconst_0(v *Value) bool {
// match: (ADDLconst [c] (ADDL x y))
// cond:
// result: (LEAL1 [c] x y)
}
return false
}
-func rewriteValue386_Op386ANDL(v *Value) bool {
+func rewriteValue386_Op386ANDL_0(v *Value) bool {
// match: (ANDL x (MOVLconst [c]))
// cond:
// result: (ANDLconst [c] x)
}
return false
}
-func rewriteValue386_Op386ANDLconst(v *Value) bool {
+func rewriteValue386_Op386ANDLconst_0(v *Value) bool {
// match: (ANDLconst [c] (ANDLconst [d] x))
// cond:
// result: (ANDLconst [c & d] x)
}
return false
}
-func rewriteValue386_Op386CMPB(v *Value) bool {
+func rewriteValue386_Op386CMPB_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPB x (MOVLconst [c]))
}
return false
}
-func rewriteValue386_Op386CMPBconst(v *Value) bool {
+func rewriteValue386_Op386CMPBconst_0(v *Value) bool {
// match: (CMPBconst (MOVLconst [x]) [y])
// cond: int8(x)==int8(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValue386_Op386CMPL(v *Value) bool {
+func rewriteValue386_Op386CMPL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPL x (MOVLconst [c]))
}
return false
}
-func rewriteValue386_Op386CMPLconst(v *Value) bool {
+func rewriteValue386_Op386CMPLconst_0(v *Value) bool {
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValue386_Op386CMPW(v *Value) bool {
+func rewriteValue386_Op386CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVLconst [c]))
}
return false
}
-func rewriteValue386_Op386CMPWconst(v *Value) bool {
+func rewriteValue386_Op386CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVLconst [x]) [y])
// cond: int16(x)==int16(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValue386_Op386LEAL(v *Value) bool {
+func rewriteValue386_Op386LEAL_0(v *Value) bool {
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAL [c+d] {s} x)
}
return false
}
-func rewriteValue386_Op386LEAL1(v *Value) bool {
+func rewriteValue386_Op386LEAL1_0(v *Value) bool {
// match: (LEAL1 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL1 [c+d] {s} x y)
}
return false
}
-func rewriteValue386_Op386LEAL2(v *Value) bool {
+func rewriteValue386_Op386LEAL2_0(v *Value) bool {
// match: (LEAL2 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL2 [c+d] {s} x y)
}
return false
}
-func rewriteValue386_Op386LEAL4(v *Value) bool {
+func rewriteValue386_Op386LEAL4_0(v *Value) bool {
// match: (LEAL4 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL4 [c+d] {s} x y)
}
return false
}
-func rewriteValue386_Op386LEAL8(v *Value) bool {
+func rewriteValue386_Op386LEAL8_0(v *Value) bool {
// match: (LEAL8 [c] {s} (ADDLconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAL8 [c+d] {s} x y)
}
return false
}
-func rewriteValue386_Op386MOVBLSX(v *Value) bool {
+func rewriteValue386_Op386MOVBLSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem))
}
return false
}
-func rewriteValue386_Op386MOVBLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVBLZX(v *Value) bool {
+func rewriteValue386_Op386MOVBLZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem))
}
return false
}
-func rewriteValue386_Op386MOVBload(v *Value) bool {
+func rewriteValue386_Op386MOVBload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVBloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool {
// match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVBstore(v *Value) bool {
+func rewriteValue386_Op386MOVBstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVBstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool {
// match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem)
// cond:
// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool {
// match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool {
// match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem)
}
return false
}
-func rewriteValue386_Op386MOVLload(v *Value) bool {
+func rewriteValue386_Op386MOVLload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVLloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool {
// match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
// cond:
// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVLloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool {
// match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVLstore(v *Value) bool {
+func rewriteValue386_Op386MOVLstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVLstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool {
// match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem)
// cond:
// result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool {
// match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem)
// cond:
// result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool {
// match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem)
// cond:
// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool {
// match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVSDconst(v *Value) bool {
+func rewriteValue386_Op386MOVSDconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSDload(v *Value) bool {
+func rewriteValue386_Op386MOVSDload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool {
// match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx1 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool {
// match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVSDstore(v *Value) bool {
+func rewriteValue386_Op386MOVSDstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool {
// match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx1 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool {
+func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool {
// match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVSSconst(v *Value) bool {
+func rewriteValue386_Op386MOVSSconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSSload(v *Value) bool {
+func rewriteValue386_Op386MOVSSload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool {
// match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx1 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool {
// match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVSSstore(v *Value) bool {
+func rewriteValue386_Op386MOVSSstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool {
// match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx1 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool {
+func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool {
// match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValue386_Op386MOVWLSX(v *Value) bool {
+func rewriteValue386_Op386MOVWLSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem))
}
return false
}
-func rewriteValue386_Op386MOVWLSXload(v *Value) bool {
+func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVWLZX(v *Value) bool {
+func rewriteValue386_Op386MOVWLZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem))
}
return false
}
-func rewriteValue386_Op386MOVWload(v *Value) bool {
+func rewriteValue386_Op386MOVWload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVWloadidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool {
// match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
// cond:
// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVWloadidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool {
// match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem)
// cond:
// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVWstore(v *Value) bool {
+func rewriteValue386_Op386MOVWstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVWstoreconst(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool {
// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem)
// cond:
// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem)
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool {
// match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem)
// cond:
// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool {
// match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem)
}
return false
}
-func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool {
+func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem)
}
return false
}
-func rewriteValue386_Op386MULL(v *Value) bool {
+func rewriteValue386_Op386MULL_0(v *Value) bool {
// match: (MULL x (MOVLconst [c]))
// cond:
// result: (MULLconst [c] x)
}
return false
}
-func rewriteValue386_Op386MULLconst(v *Value) bool {
+func rewriteValue386_Op386MULLconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLconst [c] (MULLconst [d] x))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValue386_Op386MULLconst_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULLconst [21] x)
// cond:
// result: (LEAL4 x (LEAL4 <v.Type> x x))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValue386_Op386MULLconst_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULLconst [c] x)
// cond: isPowerOfTwo(c-8) && c >= 136
// result: (LEAL8 (SHLLconst <v.Type> [log2(c-8)] x) x)
}
return false
}
-func rewriteValue386_Op386NEGL(v *Value) bool {
+func rewriteValue386_Op386NEGL_0(v *Value) bool {
// match: (NEGL (MOVLconst [c]))
// cond:
// result: (MOVLconst [int64(int32(-c))])
}
return false
}
-func rewriteValue386_Op386NOTL(v *Value) bool {
+func rewriteValue386_Op386NOTL_0(v *Value) bool {
// match: (NOTL (MOVLconst [c]))
// cond:
// result: (MOVLconst [^c])
}
return false
}
-func rewriteValue386_Op386ORL(v *Value) bool {
+func rewriteValue386_Op386ORL_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)
// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s0:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
// cond: i1==i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_30(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} p idx mem)))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_40(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL x0:(MOVWloadidx1 [i0] {s} p idx mem) s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} p idx mem))))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValue386_Op386ORL_50(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORL s1:(SHLLconst [24] x2:(MOVBloadidx1 [i3] {s} idx p mem)) o0:(ORL s0:(SHLLconst [16] x1:(MOVBloadidx1 [i2] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)))
// cond: i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && o0.Uses == 1 && mergePoint(b,x0,x1,x2) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(s0) && clobber(s1) && clobber(o0)
// result: @mergePoint(b,x0,x1,x2) (MOVLloadidx1 <v.Type> [i0] {s} p idx mem)
}
return false
}
-func rewriteValue386_Op386ORLconst(v *Value) bool {
+func rewriteValue386_Op386ORLconst_0(v *Value) bool {
// match: (ORLconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValue386_Op386ROLBconst(v *Value) bool {
+func rewriteValue386_Op386ROLBconst_0(v *Value) bool {
// match: (ROLBconst [c] (ROLBconst [d] x))
// cond:
// result: (ROLBconst [(c+d)& 7] x)
}
return false
}
-func rewriteValue386_Op386ROLLconst(v *Value) bool {
+func rewriteValue386_Op386ROLLconst_0(v *Value) bool {
// match: (ROLLconst [c] (ROLLconst [d] x))
// cond:
// result: (ROLLconst [(c+d)&31] x)
}
return false
}
-func rewriteValue386_Op386ROLWconst(v *Value) bool {
+func rewriteValue386_Op386ROLWconst_0(v *Value) bool {
// match: (ROLWconst [c] (ROLWconst [d] x))
// cond:
// result: (ROLWconst [(c+d)&15] x)
}
return false
}
-func rewriteValue386_Op386SARB(v *Value) bool {
+func rewriteValue386_Op386SARB_0(v *Value) bool {
// match: (SARB x (MOVLconst [c]))
// cond:
// result: (SARBconst [min(c&31,7)] x)
}
return false
}
-func rewriteValue386_Op386SARBconst(v *Value) bool {
+func rewriteValue386_Op386SARBconst_0(v *Value) bool {
// match: (SARBconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SARL(v *Value) bool {
+func rewriteValue386_Op386SARL_0(v *Value) bool {
// match: (SARL x (MOVLconst [c]))
// cond:
// result: (SARLconst [c&31] x)
}
return false
}
-func rewriteValue386_Op386SARLconst(v *Value) bool {
+func rewriteValue386_Op386SARLconst_0(v *Value) bool {
// match: (SARLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SARW(v *Value) bool {
+func rewriteValue386_Op386SARW_0(v *Value) bool {
// match: (SARW x (MOVLconst [c]))
// cond:
// result: (SARWconst [min(c&31,15)] x)
}
return false
}
-func rewriteValue386_Op386SARWconst(v *Value) bool {
+func rewriteValue386_Op386SARWconst_0(v *Value) bool {
// match: (SARWconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SBBL(v *Value) bool {
+func rewriteValue386_Op386SBBL_0(v *Value) bool {
// match: (SBBL x (MOVLconst [c]) f)
// cond:
// result: (SBBLconst [c] x f)
}
return false
}
-func rewriteValue386_Op386SBBLcarrymask(v *Value) bool {
+func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool {
// match: (SBBLcarrymask (FlagEQ))
// cond:
// result: (MOVLconst [0])
}
return false
}
-func rewriteValue386_Op386SETA(v *Value) bool {
+func rewriteValue386_Op386SETA_0(v *Value) bool {
// match: (SETA (InvertFlags x))
// cond:
// result: (SETB x)
}
return false
}
-func rewriteValue386_Op386SETAE(v *Value) bool {
+func rewriteValue386_Op386SETAE_0(v *Value) bool {
// match: (SETAE (InvertFlags x))
// cond:
// result: (SETBE x)
}
return false
}
-func rewriteValue386_Op386SETB(v *Value) bool {
+func rewriteValue386_Op386SETB_0(v *Value) bool {
// match: (SETB (InvertFlags x))
// cond:
// result: (SETA x)
}
return false
}
-func rewriteValue386_Op386SETBE(v *Value) bool {
+func rewriteValue386_Op386SETBE_0(v *Value) bool {
// match: (SETBE (InvertFlags x))
// cond:
// result: (SETAE x)
}
return false
}
-func rewriteValue386_Op386SETEQ(v *Value) bool {
+func rewriteValue386_Op386SETEQ_0(v *Value) bool {
// match: (SETEQ (InvertFlags x))
// cond:
// result: (SETEQ x)
}
return false
}
-func rewriteValue386_Op386SETG(v *Value) bool {
+func rewriteValue386_Op386SETG_0(v *Value) bool {
// match: (SETG (InvertFlags x))
// cond:
// result: (SETL x)
}
return false
}
-func rewriteValue386_Op386SETGE(v *Value) bool {
+func rewriteValue386_Op386SETGE_0(v *Value) bool {
// match: (SETGE (InvertFlags x))
// cond:
// result: (SETLE x)
}
return false
}
-func rewriteValue386_Op386SETL(v *Value) bool {
+func rewriteValue386_Op386SETL_0(v *Value) bool {
// match: (SETL (InvertFlags x))
// cond:
// result: (SETG x)
}
return false
}
-func rewriteValue386_Op386SETLE(v *Value) bool {
+func rewriteValue386_Op386SETLE_0(v *Value) bool {
// match: (SETLE (InvertFlags x))
// cond:
// result: (SETGE x)
}
return false
}
-func rewriteValue386_Op386SETNE(v *Value) bool {
+func rewriteValue386_Op386SETNE_0(v *Value) bool {
// match: (SETNE (InvertFlags x))
// cond:
// result: (SETNE x)
}
return false
}
-func rewriteValue386_Op386SHLL(v *Value) bool {
+func rewriteValue386_Op386SHLL_0(v *Value) bool {
// match: (SHLL x (MOVLconst [c]))
// cond:
// result: (SHLLconst [c&31] x)
}
return false
}
-func rewriteValue386_Op386SHLLconst(v *Value) bool {
+func rewriteValue386_Op386SHLLconst_0(v *Value) bool {
// match: (SHLLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SHRB(v *Value) bool {
+func rewriteValue386_Op386SHRB_0(v *Value) bool {
// match: (SHRB x (MOVLconst [c]))
// cond: c&31 < 8
// result: (SHRBconst [c&31] x)
}
return false
}
-func rewriteValue386_Op386SHRBconst(v *Value) bool {
+func rewriteValue386_Op386SHRBconst_0(v *Value) bool {
// match: (SHRBconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SHRL(v *Value) bool {
+func rewriteValue386_Op386SHRL_0(v *Value) bool {
// match: (SHRL x (MOVLconst [c]))
// cond:
// result: (SHRLconst [c&31] x)
}
return false
}
-func rewriteValue386_Op386SHRLconst(v *Value) bool {
+func rewriteValue386_Op386SHRLconst_0(v *Value) bool {
// match: (SHRLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SHRW(v *Value) bool {
+func rewriteValue386_Op386SHRW_0(v *Value) bool {
// match: (SHRW x (MOVLconst [c]))
// cond: c&31 < 16
// result: (SHRWconst [c&31] x)
}
return false
}
-func rewriteValue386_Op386SHRWconst(v *Value) bool {
+func rewriteValue386_Op386SHRWconst_0(v *Value) bool {
// match: (SHRWconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValue386_Op386SUBL(v *Value) bool {
+func rewriteValue386_Op386SUBL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBL x (MOVLconst [c]))
}
return false
}
-func rewriteValue386_Op386SUBLcarry(v *Value) bool {
+func rewriteValue386_Op386SUBLcarry_0(v *Value) bool {
// match: (SUBLcarry x (MOVLconst [c]))
// cond:
// result: (SUBLconstcarry [c] x)
}
return false
}
-func rewriteValue386_Op386SUBLconst(v *Value) bool {
+func rewriteValue386_Op386SUBLconst_0(v *Value) bool {
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
// result: x
return true
}
}
-func rewriteValue386_Op386XORL(v *Value) bool {
+func rewriteValue386_Op386XORL_0(v *Value) bool {
// match: (XORL x (MOVLconst [c]))
// cond:
// result: (XORLconst [c] x)
}
return false
}
-func rewriteValue386_Op386XORLconst(v *Value) bool {
+func rewriteValue386_Op386XORLconst_0(v *Value) bool {
// match: (XORLconst [c] (XORLconst [d] x))
// cond:
// result: (XORLconst [c ^ d] x)
}
return false
}
-func rewriteValue386_OpAdd16(v *Value) bool {
+func rewriteValue386_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValue386_OpAdd32(v *Value) bool {
+func rewriteValue386_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValue386_OpAdd32F(v *Value) bool {
+func rewriteValue386_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDSS x y)
return true
}
}
-func rewriteValue386_OpAdd32carry(v *Value) bool {
+func rewriteValue386_OpAdd32carry_0(v *Value) bool {
// match: (Add32carry x y)
// cond:
// result: (ADDLcarry x y)
return true
}
}
-func rewriteValue386_OpAdd32withcarry(v *Value) bool {
+func rewriteValue386_OpAdd32withcarry_0(v *Value) bool {
// match: (Add32withcarry x y c)
// cond:
// result: (ADCL x y c)
return true
}
}
-func rewriteValue386_OpAdd64F(v *Value) bool {
+func rewriteValue386_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDSD x y)
return true
}
}
-func rewriteValue386_OpAdd8(v *Value) bool {
+func rewriteValue386_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValue386_OpAddPtr(v *Value) bool {
+func rewriteValue386_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValue386_OpAddr(v *Value) bool {
+func rewriteValue386_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (LEAL {sym} base)
return true
}
}
-func rewriteValue386_OpAnd16(v *Value) bool {
+func rewriteValue386_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValue386_OpAnd32(v *Value) bool {
+func rewriteValue386_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValue386_OpAnd8(v *Value) bool {
+func rewriteValue386_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValue386_OpAndB(v *Value) bool {
+func rewriteValue386_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValue386_OpAvg32u(v *Value) bool {
+func rewriteValue386_OpAvg32u_0(v *Value) bool {
// match: (Avg32u x y)
// cond:
// result: (AVGLU x y)
return true
}
}
-func rewriteValue386_OpBswap32(v *Value) bool {
+func rewriteValue386_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (BSWAPL x)
return true
}
}
-func rewriteValue386_OpClosureCall(v *Value) bool {
+func rewriteValue386_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValue386_OpCom16(v *Value) bool {
+func rewriteValue386_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValue386_OpCom32(v *Value) bool {
+func rewriteValue386_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValue386_OpCom8(v *Value) bool {
+func rewriteValue386_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValue386_OpConst16(v *Value) bool {
+func rewriteValue386_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValue386_OpConst32(v *Value) bool {
+func rewriteValue386_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValue386_OpConst32F(v *Value) bool {
+func rewriteValue386_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVSSconst [val])
return true
}
}
-func rewriteValue386_OpConst64F(v *Value) bool {
+func rewriteValue386_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVSDconst [val])
return true
}
}
-func rewriteValue386_OpConst8(v *Value) bool {
+func rewriteValue386_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValue386_OpConstBool(v *Value) bool {
+func rewriteValue386_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVLconst [b])
return true
}
}
-func rewriteValue386_OpConstNil(v *Value) bool {
+func rewriteValue386_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVLconst [0])
return true
}
}
-func rewriteValue386_OpConvert(v *Value) bool {
+func rewriteValue386_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVLconvert <t> x mem)
return true
}
}
-func rewriteValue386_OpCvt32Fto32(v *Value) bool {
+func rewriteValue386_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CVTTSS2SL x)
return true
}
}
-func rewriteValue386_OpCvt32Fto64F(v *Value) bool {
+func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (CVTSS2SD x)
return true
}
}
-func rewriteValue386_OpCvt32to32F(v *Value) bool {
+func rewriteValue386_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CVTSL2SS x)
return true
}
}
-func rewriteValue386_OpCvt32to64F(v *Value) bool {
+func rewriteValue386_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CVTSL2SD x)
return true
}
}
-func rewriteValue386_OpCvt64Fto32(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CVTTSD2SL x)
return true
}
}
-func rewriteValue386_OpCvt64Fto32F(v *Value) bool {
+func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (CVTSD2SS x)
return true
}
}
-func rewriteValue386_OpDiv16(v *Value) bool {
+func rewriteValue386_OpDiv16_0(v *Value) bool {
// match: (Div16 x y)
// cond:
// result: (DIVW x y)
return true
}
}
-func rewriteValue386_OpDiv16u(v *Value) bool {
+func rewriteValue386_OpDiv16u_0(v *Value) bool {
// match: (Div16u x y)
// cond:
// result: (DIVWU x y)
return true
}
}
-func rewriteValue386_OpDiv32(v *Value) bool {
+func rewriteValue386_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVL x y)
return true
}
}
-func rewriteValue386_OpDiv32F(v *Value) bool {
+func rewriteValue386_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVSS x y)
return true
}
}
-func rewriteValue386_OpDiv32u(v *Value) bool {
+func rewriteValue386_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (DIVLU x y)
return true
}
}
-func rewriteValue386_OpDiv64F(v *Value) bool {
+func rewriteValue386_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVSD x y)
return true
}
}
-func rewriteValue386_OpDiv8(v *Value) bool {
+func rewriteValue386_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValue386_OpDiv8u(v *Value) bool {
+func rewriteValue386_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValue386_OpEq16(v *Value) bool {
+func rewriteValue386_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x y)
return true
}
}
-func rewriteValue386_OpEq32(v *Value) bool {
+func rewriteValue386_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
return true
}
}
-func rewriteValue386_OpEq32F(v *Value) bool {
+func rewriteValue386_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValue386_OpEq64F(v *Value) bool {
+func rewriteValue386_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValue386_OpEq8(v *Value) bool {
+func rewriteValue386_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x y)
return true
}
}
-func rewriteValue386_OpEqB(v *Value) bool {
+func rewriteValue386_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqB x y)
return true
}
}
-func rewriteValue386_OpEqPtr(v *Value) bool {
+func rewriteValue386_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
return true
}
}
-func rewriteValue386_OpGeq16(v *Value) bool {
+func rewriteValue386_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16 x y)
return true
}
}
-func rewriteValue386_OpGeq16U(v *Value) bool {
+func rewriteValue386_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16U x y)
return true
}
}
-func rewriteValue386_OpGeq32(v *Value) bool {
+func rewriteValue386_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
return true
}
}
-func rewriteValue386_OpGeq32F(v *Value) bool {
+func rewriteValue386_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValue386_OpGeq32U(v *Value) bool {
+func rewriteValue386_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
return true
}
}
-func rewriteValue386_OpGeq64F(v *Value) bool {
+func rewriteValue386_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValue386_OpGeq8(v *Value) bool {
+func rewriteValue386_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8 x y)
return true
}
}
-func rewriteValue386_OpGeq8U(v *Value) bool {
+func rewriteValue386_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8U x y)
return true
}
}
-func rewriteValue386_OpGetClosurePtr(v *Value) bool {
+func rewriteValue386_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValue386_OpGetG(v *Value) bool {
+func rewriteValue386_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
return true
}
}
-func rewriteValue386_OpGreater16(v *Value) bool {
+func rewriteValue386_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16 x y)
return true
}
}
-func rewriteValue386_OpGreater16U(v *Value) bool {
+func rewriteValue386_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16U x y)
return true
}
}
-func rewriteValue386_OpGreater32(v *Value) bool {
+func rewriteValue386_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
return true
}
}
-func rewriteValue386_OpGreater32F(v *Value) bool {
+func rewriteValue386_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValue386_OpGreater32U(v *Value) bool {
+func rewriteValue386_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
return true
}
}
-func rewriteValue386_OpGreater64F(v *Value) bool {
+func rewriteValue386_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValue386_OpGreater8(v *Value) bool {
+func rewriteValue386_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8 x y)
return true
}
}
-func rewriteValue386_OpGreater8U(v *Value) bool {
+func rewriteValue386_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8U x y)
return true
}
}
-func rewriteValue386_OpHmul32(v *Value) bool {
+func rewriteValue386_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMULL x y)
return true
}
}
-func rewriteValue386_OpHmul32u(v *Value) bool {
+func rewriteValue386_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULLU x y)
return true
}
}
-func rewriteValue386_OpInterCall(v *Value) bool {
+func rewriteValue386_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValue386_OpIsInBounds(v *Value) bool {
+func rewriteValue386_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
return true
}
}
-func rewriteValue386_OpIsNonNil(v *Value) bool {
+func rewriteValue386_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil p)
return true
}
}
-func rewriteValue386_OpIsSliceInBounds(v *Value) bool {
+func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
return true
}
}
-func rewriteValue386_OpLeq16(v *Value) bool {
+func rewriteValue386_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16 x y)
return true
}
}
-func rewriteValue386_OpLeq16U(v *Value) bool {
+func rewriteValue386_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16U x y)
return true
}
}
-func rewriteValue386_OpLeq32(v *Value) bool {
+func rewriteValue386_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
return true
}
}
-func rewriteValue386_OpLeq32F(v *Value) bool {
+func rewriteValue386_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValue386_OpLeq32U(v *Value) bool {
+func rewriteValue386_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
return true
}
}
-func rewriteValue386_OpLeq64F(v *Value) bool {
+func rewriteValue386_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValue386_OpLeq8(v *Value) bool {
+func rewriteValue386_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8 x y)
return true
}
}
-func rewriteValue386_OpLeq8U(v *Value) bool {
+func rewriteValue386_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8U x y)
return true
}
}
-func rewriteValue386_OpLess16(v *Value) bool {
+func rewriteValue386_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16 x y)
return true
}
}
-func rewriteValue386_OpLess16U(v *Value) bool {
+func rewriteValue386_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16U x y)
return true
}
}
-func rewriteValue386_OpLess32(v *Value) bool {
+func rewriteValue386_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
return true
}
}
-func rewriteValue386_OpLess32F(v *Value) bool {
+func rewriteValue386_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValue386_OpLess32U(v *Value) bool {
+func rewriteValue386_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
return true
}
}
-func rewriteValue386_OpLess64F(v *Value) bool {
+func rewriteValue386_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValue386_OpLess8(v *Value) bool {
+func rewriteValue386_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8 x y)
return true
}
}
-func rewriteValue386_OpLess8U(v *Value) bool {
+func rewriteValue386_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8U x y)
return true
}
}
-func rewriteValue386_OpLoad(v *Value) bool {
+func rewriteValue386_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: (is32BitInt(t) || isPtr(t))
// result: (MOVLload ptr mem)
}
return false
}
-func rewriteValue386_OpLsh16x16(v *Value) bool {
+func rewriteValue386_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh16x32(v *Value) bool {
+func rewriteValue386_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh16x64(v *Value) bool {
+func rewriteValue386_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SHLLconst x [c])
}
return false
}
-func rewriteValue386_OpLsh16x8(v *Value) bool {
+func rewriteValue386_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh32x16(v *Value) bool {
+func rewriteValue386_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh32x32(v *Value) bool {
+func rewriteValue386_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh32x64(v *Value) bool {
+func rewriteValue386_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SHLLconst x [c])
}
return false
}
-func rewriteValue386_OpLsh32x8(v *Value) bool {
+func rewriteValue386_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh8x16(v *Value) bool {
+func rewriteValue386_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh8x32(v *Value) bool {
+func rewriteValue386_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
return true
}
}
-func rewriteValue386_OpLsh8x64(v *Value) bool {
+func rewriteValue386_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SHLLconst x [c])
}
return false
}
-func rewriteValue386_OpLsh8x8(v *Value) bool {
+func rewriteValue386_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x y)
return true
}
}
-func rewriteValue386_OpMod16(v *Value) bool {
+func rewriteValue386_OpMod16_0(v *Value) bool {
// match: (Mod16 x y)
// cond:
// result: (MODW x y)
return true
}
}
-func rewriteValue386_OpMod16u(v *Value) bool {
+func rewriteValue386_OpMod16u_0(v *Value) bool {
// match: (Mod16u x y)
// cond:
// result: (MODWU x y)
return true
}
}
-func rewriteValue386_OpMod32(v *Value) bool {
+func rewriteValue386_OpMod32_0(v *Value) bool {
// match: (Mod32 x y)
// cond:
// result: (MODL x y)
return true
}
}
-func rewriteValue386_OpMod32u(v *Value) bool {
+func rewriteValue386_OpMod32u_0(v *Value) bool {
// match: (Mod32u x y)
// cond:
// result: (MODLU x y)
return true
}
}
-func rewriteValue386_OpMod8(v *Value) bool {
+func rewriteValue386_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValue386_OpMod8u(v *Value) bool {
+func rewriteValue386_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValue386_OpMove(v *Value) bool {
+func rewriteValue386_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
v.AddArg(v2)
return true
}
+ return false
+}
+func rewriteValue386_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [s] dst src mem)
// cond: s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice
// result: (DUFFCOPY [10*(128-s/4)] dst src mem)
}
return false
}
-func rewriteValue386_OpMul16(v *Value) bool {
+func rewriteValue386_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValue386_OpMul32(v *Value) bool {
+func rewriteValue386_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValue386_OpMul32F(v *Value) bool {
+func rewriteValue386_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULSS x y)
return true
}
}
-func rewriteValue386_OpMul32uhilo(v *Value) bool {
+func rewriteValue386_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULLQU x y)
return true
}
}
-func rewriteValue386_OpMul64F(v *Value) bool {
+func rewriteValue386_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULSD x y)
return true
}
}
-func rewriteValue386_OpMul8(v *Value) bool {
+func rewriteValue386_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValue386_OpNeg16(v *Value) bool {
+func rewriteValue386_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValue386_OpNeg32(v *Value) bool {
+func rewriteValue386_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValue386_OpNeg32F(v *Value) bool {
+func rewriteValue386_OpNeg32F_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_OpNeg64F(v *Value) bool {
+func rewriteValue386_OpNeg64F_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValue386_OpNeg8(v *Value) bool {
+func rewriteValue386_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValue386_OpNeq16(v *Value) bool {
+func rewriteValue386_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x y)
return true
}
}
-func rewriteValue386_OpNeq32(v *Value) bool {
+func rewriteValue386_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
return true
}
}
-func rewriteValue386_OpNeq32F(v *Value) bool {
+func rewriteValue386_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValue386_OpNeq64F(v *Value) bool {
+func rewriteValue386_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValue386_OpNeq8(v *Value) bool {
+func rewriteValue386_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x y)
return true
}
}
-func rewriteValue386_OpNeqB(v *Value) bool {
+func rewriteValue386_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqB x y)
return true
}
}
-func rewriteValue386_OpNeqPtr(v *Value) bool {
+func rewriteValue386_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
return true
}
}
-func rewriteValue386_OpNilCheck(v *Value) bool {
+func rewriteValue386_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValue386_OpNot(v *Value) bool {
+func rewriteValue386_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORLconst [1] x)
return true
}
}
-func rewriteValue386_OpOffPtr(v *Value) bool {
+func rewriteValue386_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr)
// cond:
// result: (ADDLconst [off] ptr)
return true
}
}
-func rewriteValue386_OpOr16(v *Value) bool {
+func rewriteValue386_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValue386_OpOr32(v *Value) bool {
+func rewriteValue386_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValue386_OpOr8(v *Value) bool {
+func rewriteValue386_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValue386_OpOrB(v *Value) bool {
+func rewriteValue386_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValue386_OpRound32F(v *Value) bool {
+func rewriteValue386_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValue386_OpRound64F(v *Value) bool {
+func rewriteValue386_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValue386_OpRsh16Ux16(v *Value) bool {
+func rewriteValue386_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh16Ux32(v *Value) bool {
+func rewriteValue386_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh16Ux64(v *Value) bool {
+func rewriteValue386_OpRsh16Ux64_0(v *Value) bool {
// match: (Rsh16Ux64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SHRWconst x [c])
}
return false
}
-func rewriteValue386_OpRsh16Ux8(v *Value) bool {
+func rewriteValue386_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh16x16(v *Value) bool {
+func rewriteValue386_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh16x32(v *Value) bool {
+func rewriteValue386_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh16x64(v *Value) bool {
+func rewriteValue386_OpRsh16x64_0(v *Value) bool {
// match: (Rsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SARWconst x [c])
}
return false
}
-func rewriteValue386_OpRsh16x8(v *Value) bool {
+func rewriteValue386_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32Ux16(v *Value) bool {
+func rewriteValue386_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32Ux32(v *Value) bool {
+func rewriteValue386_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32Ux64(v *Value) bool {
+func rewriteValue386_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SHRLconst x [c])
}
return false
}
-func rewriteValue386_OpRsh32Ux8(v *Value) bool {
+func rewriteValue386_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32x16(v *Value) bool {
+func rewriteValue386_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32x32(v *Value) bool {
+func rewriteValue386_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh32x64(v *Value) bool {
+func rewriteValue386_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SARLconst x [c])
}
return false
}
-func rewriteValue386_OpRsh32x8(v *Value) bool {
+func rewriteValue386_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8Ux16(v *Value) bool {
+func rewriteValue386_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8Ux32(v *Value) bool {
+func rewriteValue386_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8Ux64(v *Value) bool {
+func rewriteValue386_OpRsh8Ux64_0(v *Value) bool {
// match: (Rsh8Ux64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SHRBconst x [c])
}
return false
}
-func rewriteValue386_OpRsh8Ux8(v *Value) bool {
+func rewriteValue386_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8x16(v *Value) bool {
+func rewriteValue386_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8x32(v *Value) bool {
+func rewriteValue386_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x y)
return true
}
}
-func rewriteValue386_OpRsh8x64(v *Value) bool {
+func rewriteValue386_OpRsh8x64_0(v *Value) bool {
// match: (Rsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SARBconst x [c])
}
return false
}
-func rewriteValue386_OpRsh8x8(v *Value) bool {
+func rewriteValue386_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x y)
return true
}
}
-func rewriteValue386_OpSignExt16to32(v *Value) bool {
+func rewriteValue386_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVWLSX x)
return true
}
}
-func rewriteValue386_OpSignExt8to16(v *Value) bool {
+func rewriteValue386_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBLSX x)
return true
}
}
-func rewriteValue386_OpSignExt8to32(v *Value) bool {
+func rewriteValue386_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBLSX x)
return true
}
}
-func rewriteValue386_OpSignmask(v *Value) bool {
+func rewriteValue386_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SARLconst x [31])
return true
}
}
-func rewriteValue386_OpSlicemask(v *Value) bool {
+func rewriteValue386_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValue386_OpSqrt(v *Value) bool {
+func rewriteValue386_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTSD x)
return true
}
}
-func rewriteValue386_OpStaticCall(v *Value) bool {
+func rewriteValue386_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValue386_OpStore(v *Value) bool {
+func rewriteValue386_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
}
return false
}
-func rewriteValue386_OpSub16(v *Value) bool {
+func rewriteValue386_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValue386_OpSub32(v *Value) bool {
+func rewriteValue386_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValue386_OpSub32F(v *Value) bool {
+func rewriteValue386_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBSS x y)
return true
}
}
-func rewriteValue386_OpSub32carry(v *Value) bool {
+func rewriteValue386_OpSub32carry_0(v *Value) bool {
// match: (Sub32carry x y)
// cond:
// result: (SUBLcarry x y)
return true
}
}
-func rewriteValue386_OpSub32withcarry(v *Value) bool {
+func rewriteValue386_OpSub32withcarry_0(v *Value) bool {
// match: (Sub32withcarry x y c)
// cond:
// result: (SBBL x y c)
return true
}
}
-func rewriteValue386_OpSub64F(v *Value) bool {
+func rewriteValue386_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBSD x y)
return true
}
}
-func rewriteValue386_OpSub8(v *Value) bool {
+func rewriteValue386_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValue386_OpSubPtr(v *Value) bool {
+func rewriteValue386_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValue386_OpTrunc16to8(v *Value) bool {
+func rewriteValue386_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValue386_OpTrunc32to16(v *Value) bool {
+func rewriteValue386_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValue386_OpTrunc32to8(v *Value) bool {
+func rewriteValue386_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValue386_OpXor16(v *Value) bool {
+func rewriteValue386_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValue386_OpXor32(v *Value) bool {
+func rewriteValue386_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValue386_OpXor8(v *Value) bool {
+func rewriteValue386_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValue386_OpZero(v *Value) bool {
+func rewriteValue386_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValue386_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [12] destptr mem)
// cond:
// result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem)))
}
return false
}
-func rewriteValue386_OpZeroExt16to32(v *Value) bool {
+func rewriteValue386_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVWLZX x)
return true
}
}
-func rewriteValue386_OpZeroExt8to16(v *Value) bool {
+func rewriteValue386_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBLZX x)
return true
}
}
-func rewriteValue386_OpZeroExt8to32(v *Value) bool {
+func rewriteValue386_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBLZX x)
return true
}
}
-func rewriteValue386_OpZeromask(v *Value) bool {
+func rewriteValue386_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zeromask <t> x)
func rewriteValueAMD64(v *Value) bool {
switch v.Op {
case OpAMD64ADDL:
- return rewriteValueAMD64_OpAMD64ADDL(v)
+ return rewriteValueAMD64_OpAMD64ADDL_0(v) || rewriteValueAMD64_OpAMD64ADDL_10(v)
case OpAMD64ADDLconst:
- return rewriteValueAMD64_OpAMD64ADDLconst(v)
+ return rewriteValueAMD64_OpAMD64ADDLconst_0(v)
case OpAMD64ADDQ:
- return rewriteValueAMD64_OpAMD64ADDQ(v)
+ return rewriteValueAMD64_OpAMD64ADDQ_0(v) || rewriteValueAMD64_OpAMD64ADDQ_10(v) || rewriteValueAMD64_OpAMD64ADDQ_20(v)
case OpAMD64ADDQconst:
- return rewriteValueAMD64_OpAMD64ADDQconst(v)
+ return rewriteValueAMD64_OpAMD64ADDQconst_0(v)
case OpAMD64ADDSD:
- return rewriteValueAMD64_OpAMD64ADDSD(v)
+ return rewriteValueAMD64_OpAMD64ADDSD_0(v)
case OpAMD64ADDSS:
- return rewriteValueAMD64_OpAMD64ADDSS(v)
+ return rewriteValueAMD64_OpAMD64ADDSS_0(v)
case OpAMD64ANDL:
- return rewriteValueAMD64_OpAMD64ANDL(v)
+ return rewriteValueAMD64_OpAMD64ANDL_0(v)
case OpAMD64ANDLconst:
- return rewriteValueAMD64_OpAMD64ANDLconst(v)
+ return rewriteValueAMD64_OpAMD64ANDLconst_0(v)
case OpAMD64ANDQ:
- return rewriteValueAMD64_OpAMD64ANDQ(v)
+ return rewriteValueAMD64_OpAMD64ANDQ_0(v)
case OpAMD64ANDQconst:
- return rewriteValueAMD64_OpAMD64ANDQconst(v)
+ return rewriteValueAMD64_OpAMD64ANDQconst_0(v)
case OpAMD64BSFQ:
- return rewriteValueAMD64_OpAMD64BSFQ(v)
+ return rewriteValueAMD64_OpAMD64BSFQ_0(v)
case OpAMD64BTQconst:
- return rewriteValueAMD64_OpAMD64BTQconst(v)
+ return rewriteValueAMD64_OpAMD64BTQconst_0(v)
case OpAMD64CMOVQEQ:
- return rewriteValueAMD64_OpAMD64CMOVQEQ(v)
+ return rewriteValueAMD64_OpAMD64CMOVQEQ_0(v)
case OpAMD64CMPB:
- return rewriteValueAMD64_OpAMD64CMPB(v)
+ return rewriteValueAMD64_OpAMD64CMPB_0(v)
case OpAMD64CMPBconst:
- return rewriteValueAMD64_OpAMD64CMPBconst(v)
+ return rewriteValueAMD64_OpAMD64CMPBconst_0(v)
case OpAMD64CMPL:
- return rewriteValueAMD64_OpAMD64CMPL(v)
+ return rewriteValueAMD64_OpAMD64CMPL_0(v)
case OpAMD64CMPLconst:
- return rewriteValueAMD64_OpAMD64CMPLconst(v)
+ return rewriteValueAMD64_OpAMD64CMPLconst_0(v)
case OpAMD64CMPQ:
- return rewriteValueAMD64_OpAMD64CMPQ(v)
+ return rewriteValueAMD64_OpAMD64CMPQ_0(v)
case OpAMD64CMPQconst:
- return rewriteValueAMD64_OpAMD64CMPQconst(v)
+ return rewriteValueAMD64_OpAMD64CMPQconst_0(v) || rewriteValueAMD64_OpAMD64CMPQconst_10(v)
case OpAMD64CMPW:
- return rewriteValueAMD64_OpAMD64CMPW(v)
+ return rewriteValueAMD64_OpAMD64CMPW_0(v)
case OpAMD64CMPWconst:
- return rewriteValueAMD64_OpAMD64CMPWconst(v)
+ return rewriteValueAMD64_OpAMD64CMPWconst_0(v)
case OpAMD64CMPXCHGLlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v)
case OpAMD64CMPXCHGQlock:
- return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v)
+ return rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v)
case OpAMD64LEAL:
- return rewriteValueAMD64_OpAMD64LEAL(v)
+ return rewriteValueAMD64_OpAMD64LEAL_0(v)
case OpAMD64LEAQ:
- return rewriteValueAMD64_OpAMD64LEAQ(v)
+ return rewriteValueAMD64_OpAMD64LEAQ_0(v)
case OpAMD64LEAQ1:
- return rewriteValueAMD64_OpAMD64LEAQ1(v)
+ return rewriteValueAMD64_OpAMD64LEAQ1_0(v)
case OpAMD64LEAQ2:
- return rewriteValueAMD64_OpAMD64LEAQ2(v)
+ return rewriteValueAMD64_OpAMD64LEAQ2_0(v)
case OpAMD64LEAQ4:
- return rewriteValueAMD64_OpAMD64LEAQ4(v)
+ return rewriteValueAMD64_OpAMD64LEAQ4_0(v)
case OpAMD64LEAQ8:
- return rewriteValueAMD64_OpAMD64LEAQ8(v)
+ return rewriteValueAMD64_OpAMD64LEAQ8_0(v)
case OpAMD64MOVBQSX:
- return rewriteValueAMD64_OpAMD64MOVBQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSX_0(v)
case OpAMD64MOVBQSXload:
- return rewriteValueAMD64_OpAMD64MOVBQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVBQSXload_0(v)
case OpAMD64MOVBQZX:
- return rewriteValueAMD64_OpAMD64MOVBQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVBQZX_0(v)
case OpAMD64MOVBload:
- return rewriteValueAMD64_OpAMD64MOVBload(v)
+ return rewriteValueAMD64_OpAMD64MOVBload_0(v)
case OpAMD64MOVBloadidx1:
- return rewriteValueAMD64_OpAMD64MOVBloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v)
case OpAMD64MOVBstore:
- return rewriteValueAMD64_OpAMD64MOVBstore(v)
+ return rewriteValueAMD64_OpAMD64MOVBstore_0(v) || rewriteValueAMD64_OpAMD64MOVBstore_10(v)
case OpAMD64MOVBstoreconst:
- return rewriteValueAMD64_OpAMD64MOVBstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v)
case OpAMD64MOVBstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v)
case OpAMD64MOVBstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v)
case OpAMD64MOVLQSX:
- return rewriteValueAMD64_OpAMD64MOVLQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSX_0(v)
case OpAMD64MOVLQSXload:
- return rewriteValueAMD64_OpAMD64MOVLQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVLQSXload_0(v)
case OpAMD64MOVLQZX:
- return rewriteValueAMD64_OpAMD64MOVLQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVLQZX_0(v)
case OpAMD64MOVLatomicload:
- return rewriteValueAMD64_OpAMD64MOVLatomicload(v)
+ return rewriteValueAMD64_OpAMD64MOVLatomicload_0(v)
case OpAMD64MOVLload:
- return rewriteValueAMD64_OpAMD64MOVLload(v)
+ return rewriteValueAMD64_OpAMD64MOVLload_0(v)
case OpAMD64MOVLloadidx1:
- return rewriteValueAMD64_OpAMD64MOVLloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v)
case OpAMD64MOVLloadidx4:
- return rewriteValueAMD64_OpAMD64MOVLloadidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v)
case OpAMD64MOVLstore:
- return rewriteValueAMD64_OpAMD64MOVLstore(v)
+ return rewriteValueAMD64_OpAMD64MOVLstore_0(v) || rewriteValueAMD64_OpAMD64MOVLstore_10(v)
case OpAMD64MOVLstoreconst:
- return rewriteValueAMD64_OpAMD64MOVLstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v)
case OpAMD64MOVLstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v)
case OpAMD64MOVLstoreconstidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v)
case OpAMD64MOVLstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v)
case OpAMD64MOVLstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v)
case OpAMD64MOVOload:
- return rewriteValueAMD64_OpAMD64MOVOload(v)
+ return rewriteValueAMD64_OpAMD64MOVOload_0(v)
case OpAMD64MOVOstore:
- return rewriteValueAMD64_OpAMD64MOVOstore(v)
+ return rewriteValueAMD64_OpAMD64MOVOstore_0(v)
case OpAMD64MOVQatomicload:
- return rewriteValueAMD64_OpAMD64MOVQatomicload(v)
+ return rewriteValueAMD64_OpAMD64MOVQatomicload_0(v)
case OpAMD64MOVQload:
- return rewriteValueAMD64_OpAMD64MOVQload(v)
+ return rewriteValueAMD64_OpAMD64MOVQload_0(v)
case OpAMD64MOVQloadidx1:
- return rewriteValueAMD64_OpAMD64MOVQloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v)
case OpAMD64MOVQloadidx8:
- return rewriteValueAMD64_OpAMD64MOVQloadidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v)
case OpAMD64MOVQstore:
- return rewriteValueAMD64_OpAMD64MOVQstore(v)
+ return rewriteValueAMD64_OpAMD64MOVQstore_0(v)
case OpAMD64MOVQstoreconst:
- return rewriteValueAMD64_OpAMD64MOVQstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v)
case OpAMD64MOVQstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v)
case OpAMD64MOVQstoreconstidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v)
case OpAMD64MOVQstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v)
case OpAMD64MOVQstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v)
case OpAMD64MOVSDload:
- return rewriteValueAMD64_OpAMD64MOVSDload(v)
+ return rewriteValueAMD64_OpAMD64MOVSDload_0(v)
case OpAMD64MOVSDloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v)
case OpAMD64MOVSDloadidx8:
- return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v)
case OpAMD64MOVSDstore:
- return rewriteValueAMD64_OpAMD64MOVSDstore(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstore_0(v)
case OpAMD64MOVSDstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v)
case OpAMD64MOVSDstoreidx8:
- return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v)
+ return rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v)
case OpAMD64MOVSSload:
- return rewriteValueAMD64_OpAMD64MOVSSload(v)
+ return rewriteValueAMD64_OpAMD64MOVSSload_0(v)
case OpAMD64MOVSSloadidx1:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v)
case OpAMD64MOVSSloadidx4:
- return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v)
case OpAMD64MOVSSstore:
- return rewriteValueAMD64_OpAMD64MOVSSstore(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstore_0(v)
case OpAMD64MOVSSstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v)
case OpAMD64MOVSSstoreidx4:
- return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v)
+ return rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v)
case OpAMD64MOVWQSX:
- return rewriteValueAMD64_OpAMD64MOVWQSX(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSX_0(v)
case OpAMD64MOVWQSXload:
- return rewriteValueAMD64_OpAMD64MOVWQSXload(v)
+ return rewriteValueAMD64_OpAMD64MOVWQSXload_0(v)
case OpAMD64MOVWQZX:
- return rewriteValueAMD64_OpAMD64MOVWQZX(v)
+ return rewriteValueAMD64_OpAMD64MOVWQZX_0(v)
case OpAMD64MOVWload:
- return rewriteValueAMD64_OpAMD64MOVWload(v)
+ return rewriteValueAMD64_OpAMD64MOVWload_0(v)
case OpAMD64MOVWloadidx1:
- return rewriteValueAMD64_OpAMD64MOVWloadidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v)
case OpAMD64MOVWloadidx2:
- return rewriteValueAMD64_OpAMD64MOVWloadidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v)
case OpAMD64MOVWstore:
- return rewriteValueAMD64_OpAMD64MOVWstore(v)
+ return rewriteValueAMD64_OpAMD64MOVWstore_0(v) || rewriteValueAMD64_OpAMD64MOVWstore_10(v)
case OpAMD64MOVWstoreconst:
- return rewriteValueAMD64_OpAMD64MOVWstoreconst(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v)
case OpAMD64MOVWstoreconstidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v)
case OpAMD64MOVWstoreconstidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v)
case OpAMD64MOVWstoreidx1:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v)
case OpAMD64MOVWstoreidx2:
- return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v)
+ return rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v)
case OpAMD64MULL:
- return rewriteValueAMD64_OpAMD64MULL(v)
+ return rewriteValueAMD64_OpAMD64MULL_0(v)
case OpAMD64MULLconst:
- return rewriteValueAMD64_OpAMD64MULLconst(v)
+ return rewriteValueAMD64_OpAMD64MULLconst_0(v)
case OpAMD64MULQ:
- return rewriteValueAMD64_OpAMD64MULQ(v)
+ return rewriteValueAMD64_OpAMD64MULQ_0(v)
case OpAMD64MULQconst:
- return rewriteValueAMD64_OpAMD64MULQconst(v)
+ return rewriteValueAMD64_OpAMD64MULQconst_0(v) || rewriteValueAMD64_OpAMD64MULQconst_10(v) || rewriteValueAMD64_OpAMD64MULQconst_20(v)
case OpAMD64MULSD:
- return rewriteValueAMD64_OpAMD64MULSD(v)
+ return rewriteValueAMD64_OpAMD64MULSD_0(v)
case OpAMD64MULSS:
- return rewriteValueAMD64_OpAMD64MULSS(v)
+ return rewriteValueAMD64_OpAMD64MULSS_0(v)
case OpAMD64NEGL:
- return rewriteValueAMD64_OpAMD64NEGL(v)
+ return rewriteValueAMD64_OpAMD64NEGL_0(v)
case OpAMD64NEGQ:
- return rewriteValueAMD64_OpAMD64NEGQ(v)
+ return rewriteValueAMD64_OpAMD64NEGQ_0(v)
case OpAMD64NOTL:
- return rewriteValueAMD64_OpAMD64NOTL(v)
+ return rewriteValueAMD64_OpAMD64NOTL_0(v)
case OpAMD64NOTQ:
- return rewriteValueAMD64_OpAMD64NOTQ(v)
+ return rewriteValueAMD64_OpAMD64NOTQ_0(v)
case OpAMD64ORL:
- return rewriteValueAMD64_OpAMD64ORL(v)
+ return rewriteValueAMD64_OpAMD64ORL_0(v) || rewriteValueAMD64_OpAMD64ORL_10(v) || rewriteValueAMD64_OpAMD64ORL_20(v) || rewriteValueAMD64_OpAMD64ORL_30(v) || rewriteValueAMD64_OpAMD64ORL_40(v) || rewriteValueAMD64_OpAMD64ORL_50(v) || rewriteValueAMD64_OpAMD64ORL_60(v) || rewriteValueAMD64_OpAMD64ORL_70(v) || rewriteValueAMD64_OpAMD64ORL_80(v) || rewriteValueAMD64_OpAMD64ORL_90(v) || rewriteValueAMD64_OpAMD64ORL_100(v) || rewriteValueAMD64_OpAMD64ORL_110(v) || rewriteValueAMD64_OpAMD64ORL_120(v) || rewriteValueAMD64_OpAMD64ORL_130(v)
case OpAMD64ORLconst:
- return rewriteValueAMD64_OpAMD64ORLconst(v)
+ return rewriteValueAMD64_OpAMD64ORLconst_0(v)
case OpAMD64ORQ:
- return rewriteValueAMD64_OpAMD64ORQ(v)
+ return rewriteValueAMD64_OpAMD64ORQ_0(v) || rewriteValueAMD64_OpAMD64ORQ_10(v) || rewriteValueAMD64_OpAMD64ORQ_20(v) || rewriteValueAMD64_OpAMD64ORQ_30(v) || rewriteValueAMD64_OpAMD64ORQ_40(v) || rewriteValueAMD64_OpAMD64ORQ_50(v) || rewriteValueAMD64_OpAMD64ORQ_60(v) || rewriteValueAMD64_OpAMD64ORQ_70(v) || rewriteValueAMD64_OpAMD64ORQ_80(v) || rewriteValueAMD64_OpAMD64ORQ_90(v) || rewriteValueAMD64_OpAMD64ORQ_100(v) || rewriteValueAMD64_OpAMD64ORQ_110(v) || rewriteValueAMD64_OpAMD64ORQ_120(v) || rewriteValueAMD64_OpAMD64ORQ_130(v) || rewriteValueAMD64_OpAMD64ORQ_140(v) || rewriteValueAMD64_OpAMD64ORQ_150(v) || rewriteValueAMD64_OpAMD64ORQ_160(v)
case OpAMD64ORQconst:
- return rewriteValueAMD64_OpAMD64ORQconst(v)
+ return rewriteValueAMD64_OpAMD64ORQconst_0(v)
case OpAMD64ROLB:
- return rewriteValueAMD64_OpAMD64ROLB(v)
+ return rewriteValueAMD64_OpAMD64ROLB_0(v)
case OpAMD64ROLBconst:
- return rewriteValueAMD64_OpAMD64ROLBconst(v)
+ return rewriteValueAMD64_OpAMD64ROLBconst_0(v)
case OpAMD64ROLL:
- return rewriteValueAMD64_OpAMD64ROLL(v)
+ return rewriteValueAMD64_OpAMD64ROLL_0(v)
case OpAMD64ROLLconst:
- return rewriteValueAMD64_OpAMD64ROLLconst(v)
+ return rewriteValueAMD64_OpAMD64ROLLconst_0(v)
case OpAMD64ROLQ:
- return rewriteValueAMD64_OpAMD64ROLQ(v)
+ return rewriteValueAMD64_OpAMD64ROLQ_0(v)
case OpAMD64ROLQconst:
- return rewriteValueAMD64_OpAMD64ROLQconst(v)
+ return rewriteValueAMD64_OpAMD64ROLQconst_0(v)
case OpAMD64ROLW:
- return rewriteValueAMD64_OpAMD64ROLW(v)
+ return rewriteValueAMD64_OpAMD64ROLW_0(v)
case OpAMD64ROLWconst:
- return rewriteValueAMD64_OpAMD64ROLWconst(v)
+ return rewriteValueAMD64_OpAMD64ROLWconst_0(v)
case OpAMD64RORB:
- return rewriteValueAMD64_OpAMD64RORB(v)
+ return rewriteValueAMD64_OpAMD64RORB_0(v)
case OpAMD64RORL:
- return rewriteValueAMD64_OpAMD64RORL(v)
+ return rewriteValueAMD64_OpAMD64RORL_0(v)
case OpAMD64RORQ:
- return rewriteValueAMD64_OpAMD64RORQ(v)
+ return rewriteValueAMD64_OpAMD64RORQ_0(v)
case OpAMD64RORW:
- return rewriteValueAMD64_OpAMD64RORW(v)
+ return rewriteValueAMD64_OpAMD64RORW_0(v)
case OpAMD64SARB:
- return rewriteValueAMD64_OpAMD64SARB(v)
+ return rewriteValueAMD64_OpAMD64SARB_0(v)
case OpAMD64SARBconst:
- return rewriteValueAMD64_OpAMD64SARBconst(v)
+ return rewriteValueAMD64_OpAMD64SARBconst_0(v)
case OpAMD64SARL:
- return rewriteValueAMD64_OpAMD64SARL(v)
+ return rewriteValueAMD64_OpAMD64SARL_0(v)
case OpAMD64SARLconst:
- return rewriteValueAMD64_OpAMD64SARLconst(v)
+ return rewriteValueAMD64_OpAMD64SARLconst_0(v)
case OpAMD64SARQ:
- return rewriteValueAMD64_OpAMD64SARQ(v)
+ return rewriteValueAMD64_OpAMD64SARQ_0(v)
case OpAMD64SARQconst:
- return rewriteValueAMD64_OpAMD64SARQconst(v)
+ return rewriteValueAMD64_OpAMD64SARQconst_0(v)
case OpAMD64SARW:
- return rewriteValueAMD64_OpAMD64SARW(v)
+ return rewriteValueAMD64_OpAMD64SARW_0(v)
case OpAMD64SARWconst:
- return rewriteValueAMD64_OpAMD64SARWconst(v)
+ return rewriteValueAMD64_OpAMD64SARWconst_0(v)
case OpAMD64SBBLcarrymask:
- return rewriteValueAMD64_OpAMD64SBBLcarrymask(v)
+ return rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v)
case OpAMD64SBBQcarrymask:
- return rewriteValueAMD64_OpAMD64SBBQcarrymask(v)
+ return rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v)
case OpAMD64SETA:
- return rewriteValueAMD64_OpAMD64SETA(v)
+ return rewriteValueAMD64_OpAMD64SETA_0(v)
case OpAMD64SETAE:
- return rewriteValueAMD64_OpAMD64SETAE(v)
+ return rewriteValueAMD64_OpAMD64SETAE_0(v)
case OpAMD64SETB:
- return rewriteValueAMD64_OpAMD64SETB(v)
+ return rewriteValueAMD64_OpAMD64SETB_0(v)
case OpAMD64SETBE:
- return rewriteValueAMD64_OpAMD64SETBE(v)
+ return rewriteValueAMD64_OpAMD64SETBE_0(v)
case OpAMD64SETEQ:
- return rewriteValueAMD64_OpAMD64SETEQ(v)
+ return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v)
case OpAMD64SETG:
- return rewriteValueAMD64_OpAMD64SETG(v)
+ return rewriteValueAMD64_OpAMD64SETG_0(v)
case OpAMD64SETGE:
- return rewriteValueAMD64_OpAMD64SETGE(v)
+ return rewriteValueAMD64_OpAMD64SETGE_0(v)
case OpAMD64SETL:
- return rewriteValueAMD64_OpAMD64SETL(v)
+ return rewriteValueAMD64_OpAMD64SETL_0(v)
case OpAMD64SETLE:
- return rewriteValueAMD64_OpAMD64SETLE(v)
+ return rewriteValueAMD64_OpAMD64SETLE_0(v)
case OpAMD64SETNE:
- return rewriteValueAMD64_OpAMD64SETNE(v)
+ return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v)
case OpAMD64SHLL:
- return rewriteValueAMD64_OpAMD64SHLL(v)
+ return rewriteValueAMD64_OpAMD64SHLL_0(v)
case OpAMD64SHLLconst:
- return rewriteValueAMD64_OpAMD64SHLLconst(v)
+ return rewriteValueAMD64_OpAMD64SHLLconst_0(v)
case OpAMD64SHLQ:
- return rewriteValueAMD64_OpAMD64SHLQ(v)
+ return rewriteValueAMD64_OpAMD64SHLQ_0(v)
case OpAMD64SHLQconst:
- return rewriteValueAMD64_OpAMD64SHLQconst(v)
+ return rewriteValueAMD64_OpAMD64SHLQconst_0(v)
case OpAMD64SHRB:
- return rewriteValueAMD64_OpAMD64SHRB(v)
+ return rewriteValueAMD64_OpAMD64SHRB_0(v)
case OpAMD64SHRBconst:
- return rewriteValueAMD64_OpAMD64SHRBconst(v)
+ return rewriteValueAMD64_OpAMD64SHRBconst_0(v)
case OpAMD64SHRL:
- return rewriteValueAMD64_OpAMD64SHRL(v)
+ return rewriteValueAMD64_OpAMD64SHRL_0(v)
case OpAMD64SHRLconst:
- return rewriteValueAMD64_OpAMD64SHRLconst(v)
+ return rewriteValueAMD64_OpAMD64SHRLconst_0(v)
case OpAMD64SHRQ:
- return rewriteValueAMD64_OpAMD64SHRQ(v)
+ return rewriteValueAMD64_OpAMD64SHRQ_0(v)
case OpAMD64SHRQconst:
- return rewriteValueAMD64_OpAMD64SHRQconst(v)
+ return rewriteValueAMD64_OpAMD64SHRQconst_0(v)
case OpAMD64SHRW:
- return rewriteValueAMD64_OpAMD64SHRW(v)
+ return rewriteValueAMD64_OpAMD64SHRW_0(v)
case OpAMD64SHRWconst:
- return rewriteValueAMD64_OpAMD64SHRWconst(v)
+ return rewriteValueAMD64_OpAMD64SHRWconst_0(v)
case OpAMD64SUBL:
- return rewriteValueAMD64_OpAMD64SUBL(v)
+ return rewriteValueAMD64_OpAMD64SUBL_0(v)
case OpAMD64SUBLconst:
- return rewriteValueAMD64_OpAMD64SUBLconst(v)
+ return rewriteValueAMD64_OpAMD64SUBLconst_0(v)
case OpAMD64SUBQ:
- return rewriteValueAMD64_OpAMD64SUBQ(v)
+ return rewriteValueAMD64_OpAMD64SUBQ_0(v)
case OpAMD64SUBQconst:
- return rewriteValueAMD64_OpAMD64SUBQconst(v)
+ return rewriteValueAMD64_OpAMD64SUBQconst_0(v)
case OpAMD64SUBSD:
- return rewriteValueAMD64_OpAMD64SUBSD(v)
+ return rewriteValueAMD64_OpAMD64SUBSD_0(v)
case OpAMD64SUBSS:
- return rewriteValueAMD64_OpAMD64SUBSS(v)
+ return rewriteValueAMD64_OpAMD64SUBSS_0(v)
case OpAMD64TESTB:
- return rewriteValueAMD64_OpAMD64TESTB(v)
+ return rewriteValueAMD64_OpAMD64TESTB_0(v)
case OpAMD64TESTL:
- return rewriteValueAMD64_OpAMD64TESTL(v)
+ return rewriteValueAMD64_OpAMD64TESTL_0(v)
case OpAMD64TESTQ:
- return rewriteValueAMD64_OpAMD64TESTQ(v)
+ return rewriteValueAMD64_OpAMD64TESTQ_0(v)
case OpAMD64TESTW:
- return rewriteValueAMD64_OpAMD64TESTW(v)
+ return rewriteValueAMD64_OpAMD64TESTW_0(v)
case OpAMD64XADDLlock:
- return rewriteValueAMD64_OpAMD64XADDLlock(v)
+ return rewriteValueAMD64_OpAMD64XADDLlock_0(v)
case OpAMD64XADDQlock:
- return rewriteValueAMD64_OpAMD64XADDQlock(v)
+ return rewriteValueAMD64_OpAMD64XADDQlock_0(v)
case OpAMD64XCHGL:
- return rewriteValueAMD64_OpAMD64XCHGL(v)
+ return rewriteValueAMD64_OpAMD64XCHGL_0(v)
case OpAMD64XCHGQ:
- return rewriteValueAMD64_OpAMD64XCHGQ(v)
+ return rewriteValueAMD64_OpAMD64XCHGQ_0(v)
case OpAMD64XORL:
- return rewriteValueAMD64_OpAMD64XORL(v)
+ return rewriteValueAMD64_OpAMD64XORL_0(v) || rewriteValueAMD64_OpAMD64XORL_10(v)
case OpAMD64XORLconst:
- return rewriteValueAMD64_OpAMD64XORLconst(v)
+ return rewriteValueAMD64_OpAMD64XORLconst_0(v)
case OpAMD64XORQ:
- return rewriteValueAMD64_OpAMD64XORQ(v)
+ return rewriteValueAMD64_OpAMD64XORQ_0(v)
case OpAMD64XORQconst:
- return rewriteValueAMD64_OpAMD64XORQconst(v)
+ return rewriteValueAMD64_OpAMD64XORQconst_0(v)
case OpAdd16:
- return rewriteValueAMD64_OpAdd16(v)
+ return rewriteValueAMD64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueAMD64_OpAdd32(v)
+ return rewriteValueAMD64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueAMD64_OpAdd32F(v)
+ return rewriteValueAMD64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueAMD64_OpAdd64(v)
+ return rewriteValueAMD64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueAMD64_OpAdd64F(v)
+ return rewriteValueAMD64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueAMD64_OpAdd8(v)
+ return rewriteValueAMD64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueAMD64_OpAddPtr(v)
+ return rewriteValueAMD64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueAMD64_OpAddr(v)
+ return rewriteValueAMD64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueAMD64_OpAnd16(v)
+ return rewriteValueAMD64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueAMD64_OpAnd32(v)
+ return rewriteValueAMD64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueAMD64_OpAnd64(v)
+ return rewriteValueAMD64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueAMD64_OpAnd8(v)
+ return rewriteValueAMD64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueAMD64_OpAndB(v)
+ return rewriteValueAMD64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueAMD64_OpAtomicAdd32(v)
+ return rewriteValueAMD64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueAMD64_OpAtomicAdd64(v)
+ return rewriteValueAMD64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValueAMD64_OpAtomicAnd8(v)
+ return rewriteValueAMD64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueAMD64_OpAtomicCompareAndSwap32(v)
+ return rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueAMD64_OpAtomicCompareAndSwap64(v)
+ return rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueAMD64_OpAtomicExchange32(v)
+ return rewriteValueAMD64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueAMD64_OpAtomicExchange64(v)
+ return rewriteValueAMD64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueAMD64_OpAtomicLoad32(v)
+ return rewriteValueAMD64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueAMD64_OpAtomicLoad64(v)
+ return rewriteValueAMD64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueAMD64_OpAtomicLoadPtr(v)
+ return rewriteValueAMD64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValueAMD64_OpAtomicOr8(v)
+ return rewriteValueAMD64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValueAMD64_OpAtomicStore32(v)
+ return rewriteValueAMD64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueAMD64_OpAtomicStore64(v)
+ return rewriteValueAMD64_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueAMD64_OpAtomicStorePtrNoWB(v)
+ return rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueAMD64_OpAvg64u(v)
+ return rewriteValueAMD64_OpAvg64u_0(v)
case OpBitLen32:
- return rewriteValueAMD64_OpBitLen32(v)
+ return rewriteValueAMD64_OpBitLen32_0(v)
case OpBitLen64:
- return rewriteValueAMD64_OpBitLen64(v)
+ return rewriteValueAMD64_OpBitLen64_0(v)
case OpBswap32:
- return rewriteValueAMD64_OpBswap32(v)
+ return rewriteValueAMD64_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueAMD64_OpBswap64(v)
+ return rewriteValueAMD64_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueAMD64_OpClosureCall(v)
+ return rewriteValueAMD64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueAMD64_OpCom16(v)
+ return rewriteValueAMD64_OpCom16_0(v)
case OpCom32:
- return rewriteValueAMD64_OpCom32(v)
+ return rewriteValueAMD64_OpCom32_0(v)
case OpCom64:
- return rewriteValueAMD64_OpCom64(v)
+ return rewriteValueAMD64_OpCom64_0(v)
case OpCom8:
- return rewriteValueAMD64_OpCom8(v)
+ return rewriteValueAMD64_OpCom8_0(v)
case OpConst16:
- return rewriteValueAMD64_OpConst16(v)
+ return rewriteValueAMD64_OpConst16_0(v)
case OpConst32:
- return rewriteValueAMD64_OpConst32(v)
+ return rewriteValueAMD64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueAMD64_OpConst32F(v)
+ return rewriteValueAMD64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueAMD64_OpConst64(v)
+ return rewriteValueAMD64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueAMD64_OpConst64F(v)
+ return rewriteValueAMD64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueAMD64_OpConst8(v)
+ return rewriteValueAMD64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueAMD64_OpConstBool(v)
+ return rewriteValueAMD64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueAMD64_OpConstNil(v)
+ return rewriteValueAMD64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueAMD64_OpConvert(v)
+ return rewriteValueAMD64_OpConvert_0(v)
case OpCtz32:
- return rewriteValueAMD64_OpCtz32(v)
+ return rewriteValueAMD64_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueAMD64_OpCtz64(v)
+ return rewriteValueAMD64_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueAMD64_OpCvt32Fto32(v)
+ return rewriteValueAMD64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueAMD64_OpCvt32Fto64(v)
+ return rewriteValueAMD64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueAMD64_OpCvt32Fto64F(v)
+ return rewriteValueAMD64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueAMD64_OpCvt32to32F(v)
+ return rewriteValueAMD64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueAMD64_OpCvt32to64F(v)
+ return rewriteValueAMD64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueAMD64_OpCvt64Fto32(v)
+ return rewriteValueAMD64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueAMD64_OpCvt64Fto32F(v)
+ return rewriteValueAMD64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueAMD64_OpCvt64Fto64(v)
+ return rewriteValueAMD64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueAMD64_OpCvt64to32F(v)
+ return rewriteValueAMD64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueAMD64_OpCvt64to64F(v)
+ return rewriteValueAMD64_OpCvt64to64F_0(v)
case OpDiv128u:
- return rewriteValueAMD64_OpDiv128u(v)
+ return rewriteValueAMD64_OpDiv128u_0(v)
case OpDiv16:
- return rewriteValueAMD64_OpDiv16(v)
+ return rewriteValueAMD64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueAMD64_OpDiv16u(v)
+ return rewriteValueAMD64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueAMD64_OpDiv32(v)
+ return rewriteValueAMD64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueAMD64_OpDiv32F(v)
+ return rewriteValueAMD64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueAMD64_OpDiv32u(v)
+ return rewriteValueAMD64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueAMD64_OpDiv64(v)
+ return rewriteValueAMD64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueAMD64_OpDiv64F(v)
+ return rewriteValueAMD64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueAMD64_OpDiv64u(v)
+ return rewriteValueAMD64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueAMD64_OpDiv8(v)
+ return rewriteValueAMD64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueAMD64_OpDiv8u(v)
+ return rewriteValueAMD64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueAMD64_OpEq16(v)
+ return rewriteValueAMD64_OpEq16_0(v)
case OpEq32:
- return rewriteValueAMD64_OpEq32(v)
+ return rewriteValueAMD64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueAMD64_OpEq32F(v)
+ return rewriteValueAMD64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueAMD64_OpEq64(v)
+ return rewriteValueAMD64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueAMD64_OpEq64F(v)
+ return rewriteValueAMD64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueAMD64_OpEq8(v)
+ return rewriteValueAMD64_OpEq8_0(v)
case OpEqB:
- return rewriteValueAMD64_OpEqB(v)
+ return rewriteValueAMD64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueAMD64_OpEqPtr(v)
+ return rewriteValueAMD64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueAMD64_OpGeq16(v)
+ return rewriteValueAMD64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueAMD64_OpGeq16U(v)
+ return rewriteValueAMD64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueAMD64_OpGeq32(v)
+ return rewriteValueAMD64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueAMD64_OpGeq32F(v)
+ return rewriteValueAMD64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueAMD64_OpGeq32U(v)
+ return rewriteValueAMD64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueAMD64_OpGeq64(v)
+ return rewriteValueAMD64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueAMD64_OpGeq64F(v)
+ return rewriteValueAMD64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueAMD64_OpGeq64U(v)
+ return rewriteValueAMD64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueAMD64_OpGeq8(v)
+ return rewriteValueAMD64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueAMD64_OpGeq8U(v)
+ return rewriteValueAMD64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueAMD64_OpGetClosurePtr(v)
+ return rewriteValueAMD64_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValueAMD64_OpGetG(v)
+ return rewriteValueAMD64_OpGetG_0(v)
case OpGreater16:
- return rewriteValueAMD64_OpGreater16(v)
+ return rewriteValueAMD64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueAMD64_OpGreater16U(v)
+ return rewriteValueAMD64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueAMD64_OpGreater32(v)
+ return rewriteValueAMD64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueAMD64_OpGreater32F(v)
+ return rewriteValueAMD64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueAMD64_OpGreater32U(v)
+ return rewriteValueAMD64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueAMD64_OpGreater64(v)
+ return rewriteValueAMD64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueAMD64_OpGreater64F(v)
+ return rewriteValueAMD64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueAMD64_OpGreater64U(v)
+ return rewriteValueAMD64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueAMD64_OpGreater8(v)
+ return rewriteValueAMD64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueAMD64_OpGreater8U(v)
+ return rewriteValueAMD64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueAMD64_OpHmul32(v)
+ return rewriteValueAMD64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueAMD64_OpHmul32u(v)
+ return rewriteValueAMD64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueAMD64_OpHmul64(v)
+ return rewriteValueAMD64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueAMD64_OpHmul64u(v)
+ return rewriteValueAMD64_OpHmul64u_0(v)
case OpInt64Hi:
- return rewriteValueAMD64_OpInt64Hi(v)
+ return rewriteValueAMD64_OpInt64Hi_0(v)
case OpInterCall:
- return rewriteValueAMD64_OpInterCall(v)
+ return rewriteValueAMD64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueAMD64_OpIsInBounds(v)
+ return rewriteValueAMD64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueAMD64_OpIsNonNil(v)
+ return rewriteValueAMD64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueAMD64_OpIsSliceInBounds(v)
+ return rewriteValueAMD64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueAMD64_OpLeq16(v)
+ return rewriteValueAMD64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueAMD64_OpLeq16U(v)
+ return rewriteValueAMD64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueAMD64_OpLeq32(v)
+ return rewriteValueAMD64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueAMD64_OpLeq32F(v)
+ return rewriteValueAMD64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueAMD64_OpLeq32U(v)
+ return rewriteValueAMD64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueAMD64_OpLeq64(v)
+ return rewriteValueAMD64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueAMD64_OpLeq64F(v)
+ return rewriteValueAMD64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueAMD64_OpLeq64U(v)
+ return rewriteValueAMD64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueAMD64_OpLeq8(v)
+ return rewriteValueAMD64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueAMD64_OpLeq8U(v)
+ return rewriteValueAMD64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueAMD64_OpLess16(v)
+ return rewriteValueAMD64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueAMD64_OpLess16U(v)
+ return rewriteValueAMD64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueAMD64_OpLess32(v)
+ return rewriteValueAMD64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueAMD64_OpLess32F(v)
+ return rewriteValueAMD64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueAMD64_OpLess32U(v)
+ return rewriteValueAMD64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueAMD64_OpLess64(v)
+ return rewriteValueAMD64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueAMD64_OpLess64F(v)
+ return rewriteValueAMD64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueAMD64_OpLess64U(v)
+ return rewriteValueAMD64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueAMD64_OpLess8(v)
+ return rewriteValueAMD64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueAMD64_OpLess8U(v)
+ return rewriteValueAMD64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueAMD64_OpLoad(v)
+ return rewriteValueAMD64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueAMD64_OpLsh16x16(v)
+ return rewriteValueAMD64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueAMD64_OpLsh16x32(v)
+ return rewriteValueAMD64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueAMD64_OpLsh16x64(v)
+ return rewriteValueAMD64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueAMD64_OpLsh16x8(v)
+ return rewriteValueAMD64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueAMD64_OpLsh32x16(v)
+ return rewriteValueAMD64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueAMD64_OpLsh32x32(v)
+ return rewriteValueAMD64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueAMD64_OpLsh32x64(v)
+ return rewriteValueAMD64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueAMD64_OpLsh32x8(v)
+ return rewriteValueAMD64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueAMD64_OpLsh64x16(v)
+ return rewriteValueAMD64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueAMD64_OpLsh64x32(v)
+ return rewriteValueAMD64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueAMD64_OpLsh64x64(v)
+ return rewriteValueAMD64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueAMD64_OpLsh64x8(v)
+ return rewriteValueAMD64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueAMD64_OpLsh8x16(v)
+ return rewriteValueAMD64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueAMD64_OpLsh8x32(v)
+ return rewriteValueAMD64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueAMD64_OpLsh8x64(v)
+ return rewriteValueAMD64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueAMD64_OpLsh8x8(v)
+ return rewriteValueAMD64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueAMD64_OpMod16(v)
+ return rewriteValueAMD64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueAMD64_OpMod16u(v)
+ return rewriteValueAMD64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueAMD64_OpMod32(v)
+ return rewriteValueAMD64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueAMD64_OpMod32u(v)
+ return rewriteValueAMD64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueAMD64_OpMod64(v)
+ return rewriteValueAMD64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueAMD64_OpMod64u(v)
+ return rewriteValueAMD64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueAMD64_OpMod8(v)
+ return rewriteValueAMD64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueAMD64_OpMod8u(v)
+ return rewriteValueAMD64_OpMod8u_0(v)
case OpMove:
- return rewriteValueAMD64_OpMove(v)
+ return rewriteValueAMD64_OpMove_0(v) || rewriteValueAMD64_OpMove_10(v)
case OpMul16:
- return rewriteValueAMD64_OpMul16(v)
+ return rewriteValueAMD64_OpMul16_0(v)
case OpMul32:
- return rewriteValueAMD64_OpMul32(v)
+ return rewriteValueAMD64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueAMD64_OpMul32F(v)
+ return rewriteValueAMD64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueAMD64_OpMul64(v)
+ return rewriteValueAMD64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueAMD64_OpMul64F(v)
+ return rewriteValueAMD64_OpMul64F_0(v)
case OpMul64uhilo:
- return rewriteValueAMD64_OpMul64uhilo(v)
+ return rewriteValueAMD64_OpMul64uhilo_0(v)
case OpMul8:
- return rewriteValueAMD64_OpMul8(v)
+ return rewriteValueAMD64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueAMD64_OpNeg16(v)
+ return rewriteValueAMD64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueAMD64_OpNeg32(v)
+ return rewriteValueAMD64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueAMD64_OpNeg32F(v)
+ return rewriteValueAMD64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueAMD64_OpNeg64(v)
+ return rewriteValueAMD64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueAMD64_OpNeg64F(v)
+ return rewriteValueAMD64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueAMD64_OpNeg8(v)
+ return rewriteValueAMD64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueAMD64_OpNeq16(v)
+ return rewriteValueAMD64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueAMD64_OpNeq32(v)
+ return rewriteValueAMD64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueAMD64_OpNeq32F(v)
+ return rewriteValueAMD64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueAMD64_OpNeq64(v)
+ return rewriteValueAMD64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueAMD64_OpNeq64F(v)
+ return rewriteValueAMD64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueAMD64_OpNeq8(v)
+ return rewriteValueAMD64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueAMD64_OpNeqB(v)
+ return rewriteValueAMD64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueAMD64_OpNeqPtr(v)
+ return rewriteValueAMD64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueAMD64_OpNilCheck(v)
+ return rewriteValueAMD64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueAMD64_OpNot(v)
+ return rewriteValueAMD64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueAMD64_OpOffPtr(v)
+ return rewriteValueAMD64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueAMD64_OpOr16(v)
+ return rewriteValueAMD64_OpOr16_0(v)
case OpOr32:
- return rewriteValueAMD64_OpOr32(v)
+ return rewriteValueAMD64_OpOr32_0(v)
case OpOr64:
- return rewriteValueAMD64_OpOr64(v)
+ return rewriteValueAMD64_OpOr64_0(v)
case OpOr8:
- return rewriteValueAMD64_OpOr8(v)
+ return rewriteValueAMD64_OpOr8_0(v)
case OpOrB:
- return rewriteValueAMD64_OpOrB(v)
+ return rewriteValueAMD64_OpOrB_0(v)
case OpPopCount16:
- return rewriteValueAMD64_OpPopCount16(v)
+ return rewriteValueAMD64_OpPopCount16_0(v)
case OpPopCount32:
- return rewriteValueAMD64_OpPopCount32(v)
+ return rewriteValueAMD64_OpPopCount32_0(v)
case OpPopCount64:
- return rewriteValueAMD64_OpPopCount64(v)
+ return rewriteValueAMD64_OpPopCount64_0(v)
case OpPopCount8:
- return rewriteValueAMD64_OpPopCount8(v)
+ return rewriteValueAMD64_OpPopCount8_0(v)
case OpRound32F:
- return rewriteValueAMD64_OpRound32F(v)
+ return rewriteValueAMD64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueAMD64_OpRound64F(v)
+ return rewriteValueAMD64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueAMD64_OpRsh16Ux16(v)
+ return rewriteValueAMD64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueAMD64_OpRsh16Ux32(v)
+ return rewriteValueAMD64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueAMD64_OpRsh16Ux64(v)
+ return rewriteValueAMD64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueAMD64_OpRsh16Ux8(v)
+ return rewriteValueAMD64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueAMD64_OpRsh16x16(v)
+ return rewriteValueAMD64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueAMD64_OpRsh16x32(v)
+ return rewriteValueAMD64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueAMD64_OpRsh16x64(v)
+ return rewriteValueAMD64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueAMD64_OpRsh16x8(v)
+ return rewriteValueAMD64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueAMD64_OpRsh32Ux16(v)
+ return rewriteValueAMD64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueAMD64_OpRsh32Ux32(v)
+ return rewriteValueAMD64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueAMD64_OpRsh32Ux64(v)
+ return rewriteValueAMD64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueAMD64_OpRsh32Ux8(v)
+ return rewriteValueAMD64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueAMD64_OpRsh32x16(v)
+ return rewriteValueAMD64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueAMD64_OpRsh32x32(v)
+ return rewriteValueAMD64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueAMD64_OpRsh32x64(v)
+ return rewriteValueAMD64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueAMD64_OpRsh32x8(v)
+ return rewriteValueAMD64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueAMD64_OpRsh64Ux16(v)
+ return rewriteValueAMD64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueAMD64_OpRsh64Ux32(v)
+ return rewriteValueAMD64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueAMD64_OpRsh64Ux64(v)
+ return rewriteValueAMD64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueAMD64_OpRsh64Ux8(v)
+ return rewriteValueAMD64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueAMD64_OpRsh64x16(v)
+ return rewriteValueAMD64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueAMD64_OpRsh64x32(v)
+ return rewriteValueAMD64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueAMD64_OpRsh64x64(v)
+ return rewriteValueAMD64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueAMD64_OpRsh64x8(v)
+ return rewriteValueAMD64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueAMD64_OpRsh8Ux16(v)
+ return rewriteValueAMD64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueAMD64_OpRsh8Ux32(v)
+ return rewriteValueAMD64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueAMD64_OpRsh8Ux64(v)
+ return rewriteValueAMD64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueAMD64_OpRsh8Ux8(v)
+ return rewriteValueAMD64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueAMD64_OpRsh8x16(v)
+ return rewriteValueAMD64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueAMD64_OpRsh8x32(v)
+ return rewriteValueAMD64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueAMD64_OpRsh8x64(v)
+ return rewriteValueAMD64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueAMD64_OpRsh8x8(v)
+ return rewriteValueAMD64_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueAMD64_OpSelect0(v)
+ return rewriteValueAMD64_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueAMD64_OpSelect1(v)
+ return rewriteValueAMD64_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueAMD64_OpSignExt16to32(v)
+ return rewriteValueAMD64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueAMD64_OpSignExt16to64(v)
+ return rewriteValueAMD64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueAMD64_OpSignExt32to64(v)
+ return rewriteValueAMD64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueAMD64_OpSignExt8to16(v)
+ return rewriteValueAMD64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueAMD64_OpSignExt8to32(v)
+ return rewriteValueAMD64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueAMD64_OpSignExt8to64(v)
+ return rewriteValueAMD64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueAMD64_OpSlicemask(v)
+ return rewriteValueAMD64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueAMD64_OpSqrt(v)
+ return rewriteValueAMD64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueAMD64_OpStaticCall(v)
+ return rewriteValueAMD64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueAMD64_OpStore(v)
+ return rewriteValueAMD64_OpStore_0(v)
case OpSub16:
- return rewriteValueAMD64_OpSub16(v)
+ return rewriteValueAMD64_OpSub16_0(v)
case OpSub32:
- return rewriteValueAMD64_OpSub32(v)
+ return rewriteValueAMD64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueAMD64_OpSub32F(v)
+ return rewriteValueAMD64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueAMD64_OpSub64(v)
+ return rewriteValueAMD64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueAMD64_OpSub64F(v)
+ return rewriteValueAMD64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueAMD64_OpSub8(v)
+ return rewriteValueAMD64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueAMD64_OpSubPtr(v)
+ return rewriteValueAMD64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueAMD64_OpTrunc16to8(v)
+ return rewriteValueAMD64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueAMD64_OpTrunc32to16(v)
+ return rewriteValueAMD64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueAMD64_OpTrunc32to8(v)
+ return rewriteValueAMD64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueAMD64_OpTrunc64to16(v)
+ return rewriteValueAMD64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueAMD64_OpTrunc64to32(v)
+ return rewriteValueAMD64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueAMD64_OpTrunc64to8(v)
+ return rewriteValueAMD64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueAMD64_OpXor16(v)
+ return rewriteValueAMD64_OpXor16_0(v)
case OpXor32:
- return rewriteValueAMD64_OpXor32(v)
+ return rewriteValueAMD64_OpXor32_0(v)
case OpXor64:
- return rewriteValueAMD64_OpXor64(v)
+ return rewriteValueAMD64_OpXor64_0(v)
case OpXor8:
- return rewriteValueAMD64_OpXor8(v)
+ return rewriteValueAMD64_OpXor8_0(v)
case OpZero:
- return rewriteValueAMD64_OpZero(v)
+ return rewriteValueAMD64_OpZero_0(v) || rewriteValueAMD64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueAMD64_OpZeroExt16to32(v)
+ return rewriteValueAMD64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueAMD64_OpZeroExt16to64(v)
+ return rewriteValueAMD64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueAMD64_OpZeroExt32to64(v)
+ return rewriteValueAMD64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueAMD64_OpZeroExt8to16(v)
+ return rewriteValueAMD64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueAMD64_OpZeroExt8to32(v)
+ return rewriteValueAMD64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueAMD64_OpZeroExt8to64(v)
+ return rewriteValueAMD64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool {
// match: (ADDL x (MOVLconst [c]))
// cond:
// result: (ADDLconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool {
// match: (ADDL x l:(MOVLload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDLmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool {
// match: (ADDLconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool {
// match: (ADDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ADDQconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool {
// match: (ADDQ x (ADDQ y y))
// cond:
// result: (LEAQ2 x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ADDQ_20(v *Value) bool {
// match: (ADDQ x (NEGQ y))
// cond:
// result: (SUBQ x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool {
// match: (ADDQconst [c] (ADDQ x y))
// cond:
// result: (LEAQ1 [c] x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool {
// match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDSDmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool {
// match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ADDSSmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool {
// match: (ANDL x (MOVLconst [c]))
// cond:
// result: (ANDLconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool {
// match: (ANDLconst [c] (ANDLconst [d] x))
// cond:
// result: (ANDLconst [c & d] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool {
// match: (ANDQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ANDQconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool {
// match: (ANDQconst [c] (ANDQconst [d] x))
// cond:
// result: (ANDQconst [c & d] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (BSFQ (ORQconst <t> [1<<8] (MOVBQZX x)))
}
return false
}
-func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64BTQconst_0(v *Value) bool {
// match: (BTQconst [c] x)
// cond: c < 32
// result: (BTLconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMOVQEQ_0(v *Value) bool {
// match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _))))
// cond: c != 0
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPB_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPB x (MOVLconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPBconst_0(v *Value) bool {
// match: (CMPBconst (MOVLconst [x]) [y])
// cond: int8(x)==int8(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPL x (MOVLconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPLconst_0(v *Value) bool {
// match: (CMPLconst (MOVLconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPQ x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPQconst_0(v *Value) bool {
// match: (CMPQconst (NEGQ (ADDQconst [-16] (ANDQconst [15] _))) [32])
// cond:
// result: (FlagLT_ULT)
v.reset(OpAMD64FlagLT_ULT)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64CMPQconst_10(v *Value) bool {
// match: (CMPQconst (SHRQconst _ [c]) [n])
// cond: 0 <= n && 0 < c && c <= 64 && (1<<uint64(64-c)) <= uint64(n)
// result: (FlagLT_ULT)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVLconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVLconst [x]) [y])
// cond: int16(x)==int16(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v *Value) bool {
// match: (CMPXCHGLlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
// cond: is32Bit(off1+off2)
// result: (CMPXCHGLlock [off1+off2] {sym} ptr old new_ mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64CMPXCHGQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v *Value) bool {
// match: (CMPXCHGQlock [off1] {sym} (ADDQconst [off2] ptr) old new_ mem)
// cond: is32Bit(off1+off2)
// result: (CMPXCHGQlock [off1+off2] {sym} ptr old new_ mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAL_0(v *Value) bool {
// match: (LEAL [c] {s} (ADDLconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAL [c+d] {s} x)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ_0(v *Value) bool {
// match: (LEAQ [c] {s} (ADDQconst [d] x))
// cond: is32Bit(c+d)
// result: (LEAQ [c+d] {s} x)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ1_0(v *Value) bool {
// match: (LEAQ1 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ1 [c+d] {s} x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ2_0(v *Value) bool {
// match: (LEAQ2 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ2 [c+d] {s} x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ4_0(v *Value) bool {
// match: (LEAQ4 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ4 [c+d] {s} x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64LEAQ8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64LEAQ8_0(v *Value) bool {
// match: (LEAQ8 [c] {s} (ADDQconst [d] x) y)
// cond: is32Bit(c+d) && x.Op != OpSB
// result: (LEAQ8 [c+d] {s} x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBQSX x:(MOVBload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQSXload_0(v *Value) bool {
// match: (MOVBQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVBQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBQZX x:(MOVBload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBload_0(v *Value) bool {
// match: (MOVBload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v *Value) bool {
// match: (MOVBloadidx1 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVBloadidx1 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstore_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBstore [off] {sym} ptr (MOVBQSX x) mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVBstore_10(v *Value) bool {
// match: (MOVBstore [i] {s} p (SHRQconst [8] w) x:(MOVBstore [i-1] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstore [i-1] {s} p w mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v *Value) bool {
// match: (MOVBstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v *Value) bool {
// match: (MOVBstoreconstidx1 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond:
// result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVBstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBstoreidx1 [c] {sym} (ADDQconst [d] ptr) idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLQSX x:(MOVLload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQSXload_0(v *Value) bool {
// match: (MOVLQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVLQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLQZX x:(MOVLload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLatomicload_0(v *Value) bool {
// match: (MOVLatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVLatomicload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLload_0(v *Value) bool {
// match: (MOVLload [off] {sym} ptr (MOVLstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v *Value) bool {
// match: (MOVLloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond:
// result: (MOVLloadidx4 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v *Value) bool {
// match: (MOVLloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVLloadidx4 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstore_0(v *Value) bool {
// match: (MOVLstore [off] {sym} ptr (MOVLQSX x) mem)
// cond:
// result: (MOVLstore [off] {sym} ptr x mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVLstore_10(v *Value) bool {
// match: (MOVLstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVLstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v *Value) bool {
// match: (MOVLstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
// cond:
// result: (MOVLstoreidx4 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVLstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVLstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOload_0(v *Value) bool {
// match: (MOVOload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVOload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVOstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVOstore_0(v *Value) bool {
// match: (MOVOstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVOstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQatomicload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQatomicload_0(v *Value) bool {
// match: (MOVQatomicload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVQatomicload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQload_0(v *Value) bool {
// match: (MOVQload [off] {sym} ptr (MOVQstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v *Value) bool {
// match: (MOVQloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVQloadidx8 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v *Value) bool {
// match: (MOVQloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVQloadidx8 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstore_0(v *Value) bool {
// match: (MOVQstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVQstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v *Value) bool {
// match: (MOVQstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVQstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v *Value) bool {
// match: (MOVQstoreconstidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVQstoreconstidx8 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v *Value) bool {
// match: (MOVQstoreconstidx8 [x] {sym} (ADDQconst [c] ptr) idx mem)
// cond:
// result: (MOVQstoreconstidx8 [ValAndOff(x).add(c)] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v *Value) bool {
// match: (MOVQstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
// cond:
// result: (MOVQstoreidx8 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVQstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v *Value) bool {
// match: (MOVQstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVQstoreidx8 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDload_0(v *Value) bool {
// match: (MOVSDload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVSDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v *Value) bool {
// match: (MOVSDloadidx1 [c] {sym} ptr (SHLQconst [3] idx) mem)
// cond:
// result: (MOVSDloadidx8 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDloadidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v *Value) bool {
// match: (MOVSDloadidx8 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstore_0(v *Value) bool {
// match: (MOVSDstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVSDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v *Value) bool {
// match: (MOVSDstoreidx1 [c] {sym} ptr (SHLQconst [3] idx) val mem)
// cond:
// result: (MOVSDstoreidx8 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v *Value) bool {
// match: (MOVSDstoreidx8 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSload_0(v *Value) bool {
// match: (MOVSSload [off1] {sym} (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVSSload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v *Value) bool {
// match: (MOVSSloadidx1 [c] {sym} ptr (SHLQconst [2] idx) mem)
// cond:
// result: (MOVSSloadidx4 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSloadidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v *Value) bool {
// match: (MOVSSloadidx4 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstore_0(v *Value) bool {
// match: (MOVSSstore [off1] {sym} (ADDQconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVSSstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v *Value) bool {
// match: (MOVSSstoreidx1 [c] {sym} ptr (SHLQconst [2] idx) val mem)
// cond:
// result: (MOVSSstoreidx4 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v *Value) bool {
// match: (MOVSSstoreidx4 [c] {sym} (ADDQconst [d] ptr) idx val mem)
// cond:
// result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWQSX x:(MOVWload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQSXload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQSXload_0(v *Value) bool {
// match: (MOVWQSXload [off1] {sym1} (LEAQ [off2] {sym2} base) mem)
// cond: is32Bit(off1+off2) && canMergeSym(sym1, sym2)
// result: (MOVWQSXload [off1+off2] {mergeSym(sym1,sym2)} base mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWQZX(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWQZX_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWQZX x:(MOVWload [off] {sym} ptr mem))
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWload(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWload_0(v *Value) bool {
// match: (MOVWload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v *Value) bool {
// match: (MOVWloadidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
// cond:
// result: (MOVWloadidx2 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWloadidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v *Value) bool {
// match: (MOVWloadidx2 [c] {sym} (ADDQconst [d] ptr) idx mem)
// cond:
// result: (MOVWloadidx2 [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstore(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWQSX x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MOVWstore_10(v *Value) bool {
// match: (MOVWstore [off1] {sym1} (LEAL [off2] {sym2} base) val mem)
// cond: canMergeSym(sym1, sym2)
// result: (MOVWstore [off1+off2] {mergeSym(sym1,sym2)} base val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v *Value) bool {
// match: (MOVWstoreconst [sc] {s} (ADDQconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVWstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v *Value) bool {
// match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLQconst [1] idx) mem)
// cond:
// result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreconstidx2 [x] {sym} (ADDQconst [c] ptr) idx mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx1(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v *Value) bool {
// match: (MOVWstoreidx1 [c] {sym} ptr (SHLQconst [1] idx) val mem)
// cond:
// result: (MOVWstoreidx2 [c] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MOVWstoreidx2(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWstoreidx2 [c] {sym} (ADDQconst [d] ptr) idx val mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULL_0(v *Value) bool {
// match: (MULL x (MOVLconst [c]))
// cond:
// result: (MULLconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULLconst_0(v *Value) bool {
// match: (MULLconst [c] (MULLconst [d] x))
// cond:
// result: (MULLconst [int64(int32(c * d))] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQ_0(v *Value) bool {
// match: (MULQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (MULQconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULQconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULQconst [c] (MULQconst [d] x))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULQconst [21] x)
// cond:
// result: (LEAQ4 x (LEAQ4 <v.Type> x x))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64MULQconst_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULQconst [c] x)
// cond: isPowerOfTwo(c-8) && c >= 136
// result: (LEAQ8 (SHLQconst <v.Type> [log2(c-8)] x) x)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool {
// match: (MULSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (MULSDmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool {
// match: (MULSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (MULSSmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool {
// match: (NEGL (MOVLconst [c]))
// cond:
// result: (MOVLconst [int64(int32(-c))])
}
return false
}
-func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool {
// match: (NEGQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [-c])
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool {
// match: (NOTL (MOVLconst [c]))
// cond:
// result: (MOVLconst [^c])
}
return false
}
-func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool {
// match: (NOTQ (MOVQconst [c]))
// cond:
// result: (MOVQconst [^c])
}
return false
}
-func rewriteValueAMD64_OpAMD64ORL(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool {
// match: (ORL x (MOVLconst [c]))
// cond:
// result: (ORLconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool {
// match: (ORL (ANDL (SHRL x (NEGQ y)) (SBBLcarrymask (CMPQconst (NEGQ (ADDQconst (ANDQconst y [31]) [-32])) [32]))) (SHLL x y))
// cond:
// result: (ROLL x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool {
// match: (ORL (SHRL x y) (ANDL (SHLL x (NEGL y)) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [31]) [-32])) [32]))))
// cond:
// result: (RORL x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool {
// match: (ORL (ANDL (SHRW x (NEGL (ADDLconst (ANDLconst y [15]) [-16]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [15]) [-16])) [16]))) (SHLL x (ANDLconst y [15])))
// cond: v.Type.Size() == 2
// result: (ROLW x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL (SHLL x (ANDLconst y [ 7])) (ANDL (SHRB x (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8])) [ 8]))))
// cond: v.Type.Size() == 1
// result: (ROLB x y)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x0:(MOVBloadidx1 [i0] {s} idx p mem) sh:(SHLLconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORL y s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [8] x0:(MOVBload [i0] {s} p mem)) x1:(MOVBload [i1] {s} p mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWload [i0] {s} p mem))
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL x1:(MOVBloadidx1 [i1] {s} idx p mem) sh:(SHLLconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL sh:(SHLLconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORL s0:(SHLLconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORL y s1:(SHLLconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORL <v.Type> (SHLLconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORL_130(v *Value) bool {
// match: (ORL l:(MOVLload [off] {sym} ptr mem) x)
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (ORLmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool {
// match: (ORLconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool {
// match: (ORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (ORQconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool {
// match: (ORQ (ANDQ (SHRQ x (NEGL y)) (SBBQcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [63]) [-64])) [64]))) (SHLQ x y))
// cond:
// result: (ROLQ x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ x x)
// cond:
// result: x
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem))) s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWload [i0] {s} p mem)) y)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [8] x1:(MOVBloadidx1 [i1] {s} idx p mem)) x0:(MOVBloadidx1 [i0] {s} p idx mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWloadidx1 <v.Type> [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem)) or:(ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)) or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} p idx mem))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s0:(SHLQconst [j0] x0:(MOVWloadidx1 [i0] {s} idx p mem))) s1:(SHLQconst [j1] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBload [i1] {s} p mem))) s0:(SHLQconst [j0] x0:(MOVBload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWload [i0] {s} p mem))) y)
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [8] x0:(MOVBloadidx1 [i0] {s} idx p mem)) x1:(MOVBloadidx1 [i1] {s} p idx mem))
// cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (ROLWconst <v.Type> [8] (MOVWloadidx1 [i0] {s} p idx mem))
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ sh:(SHLQconst [16] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (BSWAPL <v.Type> (MOVLloadidx1 [i0] {s} p idx mem))
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_130(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} idx p mem)) or:(ORQ s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_140(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] x1:(MOVBloadidx1 [i1] {s} idx p mem))) s0:(SHLQconst [j0] x0:(MOVBloadidx1 [i0] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (ROLWconst <types.UInt16> [8] (MOVWloadidx1 [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_150(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))) or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} p idx mem)))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64ORQ_160(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORQ or:(ORQ y s1:(SHLQconst [j1] r1:(ROLWconst [8] x1:(MOVWloadidx1 [i1] {s} idx p mem)))) s0:(SHLQconst [j0] r0:(ROLWconst [8] x0:(MOVWloadidx1 [i0] {s} idx p mem))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORQ <v.Type> (SHLQconst <v.Type> [j1] (BSWAPL <types.UInt32> (MOVLloadidx1 [i0] {s} p idx mem))) y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool {
// match: (ORQconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool {
// match: (ROLB x (NEGQ y))
// cond:
// result: (RORB x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool {
// match: (ROLBconst [c] (ROLBconst [d] x))
// cond:
// result: (ROLBconst [(c+d)& 7] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool {
// match: (ROLL x (NEGQ y))
// cond:
// result: (RORL x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool {
// match: (ROLLconst [c] (ROLLconst [d] x))
// cond:
// result: (ROLLconst [(c+d)&31] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool {
// match: (ROLQ x (NEGQ y))
// cond:
// result: (RORQ x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool {
// match: (ROLQconst [c] (ROLQconst [d] x))
// cond:
// result: (ROLQconst [(c+d)&63] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool {
// match: (ROLW x (NEGQ y))
// cond:
// result: (RORW x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool {
// match: (ROLWconst [c] (ROLWconst [d] x))
// cond:
// result: (ROLWconst [(c+d)&15] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64RORB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool {
// match: (RORB x (NEGQ y))
// cond:
// result: (ROLB x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64RORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool {
// match: (RORL x (NEGQ y))
// cond:
// result: (ROLL x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool {
// match: (RORQ x (NEGQ y))
// cond:
// result: (ROLQ x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64RORW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool {
// match: (RORW x (NEGQ y))
// cond:
// result: (ROLW x y)
}
return false
}
-func rewriteValueAMD64_OpAMD64SARB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool {
// match: (SARB x (MOVQconst [c]))
// cond:
// result: (SARBconst [min(c&31,7)] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool {
// match: (SARBconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SARL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SARL x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool {
// match: (SARLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SARQ x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool {
// match: (SARQconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SARW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool {
// match: (SARW x (MOVQconst [c]))
// cond:
// result: (SARWconst [min(c&31,15)] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool {
// match: (SARWconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool {
// match: (SBBLcarrymask (FlagEQ))
// cond:
// result: (MOVLconst [0])
}
return false
}
-func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool {
// match: (SBBQcarrymask (FlagEQ))
// cond:
// result: (MOVQconst [0])
}
return false
}
-func rewriteValueAMD64_OpAMD64SETA(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool {
// match: (SETA (InvertFlags x))
// cond:
// result: (SETB x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool {
// match: (SETAE (InvertFlags x))
// cond:
// result: (SETBE x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool {
// match: (SETB (InvertFlags x))
// cond:
// result: (SETA x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool {
// match: (SETBE (InvertFlags x))
// cond:
// result: (SETAE x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
v.AuxInt = 1
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool {
// match: (SETEQ (FlagLT_ULT))
// cond:
// result: (MOVLconst [0])
}
return false
}
-func rewriteValueAMD64_OpAMD64SETG(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool {
// match: (SETG (InvertFlags x))
// cond:
// result: (SETL x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool {
// match: (SETGE (InvertFlags x))
// cond:
// result: (SETLE x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool {
// match: (SETL (InvertFlags x))
// cond:
// result: (SETG x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool {
// match: (SETLE (InvertFlags x))
// cond:
// result: (SETGE x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
v.AuxInt = 0
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool {
// match: (SETNE (FlagLT_ULT))
// cond:
// result: (MOVLconst [1])
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHLL x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool {
// match: (SHLLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHLQ x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool {
// match: (SHLQconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool {
// match: (SHRB x (MOVQconst [c]))
// cond: c&31 < 8
// result: (SHRBconst [c&31] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool {
// match: (SHRBconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHRL x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool {
// match: (SHRLconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SHRQ x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool {
// match: (SHRQconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool {
// match: (SHRW x (MOVQconst [c]))
// cond: c&31 < 16
// result: (SHRWconst [c&31] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool {
// match: (SHRWconst x [0])
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBL x (MOVLconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool {
// match: (SUBLconst [c] x)
// cond: int32(c) == 0
// result: x
return true
}
}
-func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBQ x (MOVQconst [c]))
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool {
// match: (SUBQconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool {
// match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (SUBSDmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool {
+func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool {
// match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem))
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (SUBSSmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool {
// match: (TESTB (MOVLconst [c]) x)
// cond:
// result: (TESTBconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool {
// match: (TESTL (MOVLconst [c]) x)
// cond:
// result: (TESTLconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool {
// match: (TESTQ (MOVQconst [c]) x)
// cond: is32Bit(c)
// result: (TESTQconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool {
+func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool {
// match: (TESTW (MOVLconst [c]) x)
// cond:
// result: (TESTWconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool {
// match: (XADDLlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XADDLlock [off1+off2] {sym} val ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool {
// match: (XADDQlock [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XADDQlock [off1+off2] {sym} val ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool {
// match: (XCHGL [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XCHGL [off1+off2] {sym} val ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool {
// match: (XCHGQ [off1] {sym} val (ADDQconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (XCHGQ [off1+off2] {sym} val ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64XORL(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool {
// match: (XORL x (MOVLconst [c]))
// cond:
// result: (XORLconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpAMD64XORL_10(v *Value) bool {
// match: (XORL l:(MOVLload [off] {sym} ptr mem) x)
// cond: canMergeLoad(v, l, x) && clobber(l)
// result: (XORLmem x [off] {sym} ptr mem)
}
return false
}
-func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool {
// match: (XORLconst [c] (XORLconst [d] x))
// cond:
// result: (XORLconst [c ^ d] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool {
// match: (XORQ x (MOVQconst [c]))
// cond: is32Bit(c)
// result: (XORQconst [c] x)
}
return false
}
-func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool {
+func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool {
// match: (XORQconst [c] (XORQconst [d] x))
// cond:
// result: (XORQconst [c ^ d] x)
}
return false
}
-func rewriteValueAMD64_OpAdd16(v *Value) bool {
+func rewriteValueAMD64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValueAMD64_OpAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValueAMD64_OpAdd32F(v *Value) bool {
+func rewriteValueAMD64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDSS x y)
return true
}
}
-func rewriteValueAMD64_OpAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADDQ x y)
return true
}
}
-func rewriteValueAMD64_OpAdd64F(v *Value) bool {
+func rewriteValueAMD64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDSD x y)
return true
}
}
-func rewriteValueAMD64_OpAdd8(v *Value) bool {
+func rewriteValueAMD64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDL x y)
return true
}
}
-func rewriteValueAMD64_OpAddPtr(v *Value) bool {
+func rewriteValueAMD64_OpAddPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpAddr(v *Value) bool {
+func rewriteValueAMD64_OpAddr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpAnd16(v *Value) bool {
+func rewriteValueAMD64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValueAMD64_OpAnd32(v *Value) bool {
+func rewriteValueAMD64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValueAMD64_OpAnd64(v *Value) bool {
+func rewriteValueAMD64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (ANDQ x y)
return true
}
}
-func rewriteValueAMD64_OpAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValueAMD64_OpAndB(v *Value) bool {
+func rewriteValueAMD64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDL x y)
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (ANDBlock ptr val mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (CMPXCHGLlock ptr old new_ mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (CMPXCHGQlock ptr old new_ mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (XCHGL val ptr mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (XCHGQ val ptr mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (MOVLatomicload ptr mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (MOVQatomicload ptr mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueAMD64_OpAtomicLoadPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpAtomicOr8(v *Value) bool {
+func rewriteValueAMD64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (ORBlock ptr val mem)
return true
}
}
-func rewriteValueAMD64_OpAtomicStore32(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpAtomicStore64(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpAvg64u(v *Value) bool {
+func rewriteValueAMD64_OpAvg64u_0(v *Value) bool {
// match: (Avg64u x y)
// cond:
// result: (AVGQU x y)
return true
}
}
-func rewriteValueAMD64_OpBitLen32(v *Value) bool {
+func rewriteValueAMD64_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpBitLen64(v *Value) bool {
+func rewriteValueAMD64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpBswap32(v *Value) bool {
+func rewriteValueAMD64_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (BSWAPL x)
return true
}
}
-func rewriteValueAMD64_OpBswap64(v *Value) bool {
+func rewriteValueAMD64_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (BSWAPQ x)
return true
}
}
-func rewriteValueAMD64_OpClosureCall(v *Value) bool {
+func rewriteValueAMD64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueAMD64_OpCom16(v *Value) bool {
+func rewriteValueAMD64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValueAMD64_OpCom32(v *Value) bool {
+func rewriteValueAMD64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValueAMD64_OpCom64(v *Value) bool {
+func rewriteValueAMD64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOTQ x)
return true
}
}
-func rewriteValueAMD64_OpCom8(v *Value) bool {
+func rewriteValueAMD64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTL x)
return true
}
}
-func rewriteValueAMD64_OpConst16(v *Value) bool {
+func rewriteValueAMD64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValueAMD64_OpConst32(v *Value) bool {
+func rewriteValueAMD64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValueAMD64_OpConst32F(v *Value) bool {
+func rewriteValueAMD64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVSSconst [val])
return true
}
}
-func rewriteValueAMD64_OpConst64(v *Value) bool {
+func rewriteValueAMD64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVQconst [val])
return true
}
}
-func rewriteValueAMD64_OpConst64F(v *Value) bool {
+func rewriteValueAMD64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVSDconst [val])
return true
}
}
-func rewriteValueAMD64_OpConst8(v *Value) bool {
+func rewriteValueAMD64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVLconst [val])
return true
}
}
-func rewriteValueAMD64_OpConstBool(v *Value) bool {
+func rewriteValueAMD64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVLconst [b])
return true
}
}
-func rewriteValueAMD64_OpConstNil(v *Value) bool {
+func rewriteValueAMD64_OpConstNil_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpConvert(v *Value) bool {
+func rewriteValueAMD64_OpConvert_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpCtz32(v *Value) bool {
+func rewriteValueAMD64_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpCtz64(v *Value) bool {
+func rewriteValueAMD64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CVTTSS2SL x)
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (CVTTSS2SQ x)
return true
}
}
-func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (CVTSS2SD x)
return true
}
}
-func rewriteValueAMD64_OpCvt32to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CVTSL2SS x)
return true
}
}
-func rewriteValueAMD64_OpCvt32to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CVTSL2SD x)
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CVTTSD2SL x)
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (CVTSD2SS x)
return true
}
}
-func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueAMD64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (CVTTSD2SQ x)
return true
}
}
-func rewriteValueAMD64_OpCvt64to32F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (CVTSQ2SS x)
return true
}
}
-func rewriteValueAMD64_OpCvt64to64F(v *Value) bool {
+func rewriteValueAMD64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (CVTSQ2SD x)
return true
}
}
-func rewriteValueAMD64_OpDiv128u(v *Value) bool {
+func rewriteValueAMD64_OpDiv128u_0(v *Value) bool {
// match: (Div128u xhi xlo y)
// cond:
// result: (DIVQU2 xhi xlo y)
return true
}
}
-func rewriteValueAMD64_OpDiv16(v *Value) bool {
+func rewriteValueAMD64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv16u(v *Value) bool {
+func rewriteValueAMD64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv32(v *Value) bool {
+func rewriteValueAMD64_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv32F(v *Value) bool {
+func rewriteValueAMD64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVSS x y)
return true
}
}
-func rewriteValueAMD64_OpDiv32u(v *Value) bool {
+func rewriteValueAMD64_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv64(v *Value) bool {
+func rewriteValueAMD64_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv64F(v *Value) bool {
+func rewriteValueAMD64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVSD x y)
return true
}
}
-func rewriteValueAMD64_OpDiv64u(v *Value) bool {
+func rewriteValueAMD64_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv8(v *Value) bool {
+func rewriteValueAMD64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpDiv8u(v *Value) bool {
+func rewriteValueAMD64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpEq16(v *Value) bool {
+func rewriteValueAMD64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x y)
return true
}
}
-func rewriteValueAMD64_OpEq32(v *Value) bool {
+func rewriteValueAMD64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
return true
}
}
-func rewriteValueAMD64_OpEq32F(v *Value) bool {
+func rewriteValueAMD64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValueAMD64_OpEq64(v *Value) bool {
+func rewriteValueAMD64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
return true
}
}
-func rewriteValueAMD64_OpEq64F(v *Value) bool {
+func rewriteValueAMD64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValueAMD64_OpEq8(v *Value) bool {
+func rewriteValueAMD64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x y)
return true
}
}
-func rewriteValueAMD64_OpEqB(v *Value) bool {
+func rewriteValueAMD64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqB x y)
return true
}
}
-func rewriteValueAMD64_OpEqPtr(v *Value) bool {
+func rewriteValueAMD64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpGeq16(v *Value) bool {
+func rewriteValueAMD64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16 x y)
return true
}
}
-func rewriteValueAMD64_OpGeq16U(v *Value) bool {
+func rewriteValueAMD64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq16U x y)
return true
}
}
-func rewriteValueAMD64_OpGeq32(v *Value) bool {
+func rewriteValueAMD64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
return true
}
}
-func rewriteValueAMD64_OpGeq32F(v *Value) bool {
+func rewriteValueAMD64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValueAMD64_OpGeq32U(v *Value) bool {
+func rewriteValueAMD64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
return true
}
}
-func rewriteValueAMD64_OpGeq64(v *Value) bool {
+func rewriteValueAMD64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
return true
}
}
-func rewriteValueAMD64_OpGeq64F(v *Value) bool {
+func rewriteValueAMD64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValueAMD64_OpGeq64U(v *Value) bool {
+func rewriteValueAMD64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
return true
}
}
-func rewriteValueAMD64_OpGeq8(v *Value) bool {
+func rewriteValueAMD64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8 x y)
return true
}
}
-func rewriteValueAMD64_OpGeq8U(v *Value) bool {
+func rewriteValueAMD64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq8U x y)
return true
}
}
-func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueAMD64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueAMD64_OpGetG(v *Value) bool {
+func rewriteValueAMD64_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
return true
}
}
-func rewriteValueAMD64_OpGreater16(v *Value) bool {
+func rewriteValueAMD64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16 x y)
return true
}
}
-func rewriteValueAMD64_OpGreater16U(v *Value) bool {
+func rewriteValueAMD64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater16U x y)
return true
}
}
-func rewriteValueAMD64_OpGreater32(v *Value) bool {
+func rewriteValueAMD64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
return true
}
}
-func rewriteValueAMD64_OpGreater32F(v *Value) bool {
+func rewriteValueAMD64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValueAMD64_OpGreater32U(v *Value) bool {
+func rewriteValueAMD64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
return true
}
}
-func rewriteValueAMD64_OpGreater64(v *Value) bool {
+func rewriteValueAMD64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
return true
}
}
-func rewriteValueAMD64_OpGreater64F(v *Value) bool {
+func rewriteValueAMD64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValueAMD64_OpGreater64U(v *Value) bool {
+func rewriteValueAMD64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
return true
}
}
-func rewriteValueAMD64_OpGreater8(v *Value) bool {
+func rewriteValueAMD64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8 x y)
return true
}
}
-func rewriteValueAMD64_OpGreater8U(v *Value) bool {
+func rewriteValueAMD64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater8U x y)
return true
}
}
-func rewriteValueAMD64_OpHmul32(v *Value) bool {
+func rewriteValueAMD64_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMULL x y)
return true
}
}
-func rewriteValueAMD64_OpHmul32u(v *Value) bool {
+func rewriteValueAMD64_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULLU x y)
return true
}
}
-func rewriteValueAMD64_OpHmul64(v *Value) bool {
+func rewriteValueAMD64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (HMULQ x y)
return true
}
}
-func rewriteValueAMD64_OpHmul64u(v *Value) bool {
+func rewriteValueAMD64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (HMULQU x y)
return true
}
}
-func rewriteValueAMD64_OpInt64Hi(v *Value) bool {
+func rewriteValueAMD64_OpInt64Hi_0(v *Value) bool {
// match: (Int64Hi x)
// cond:
// result: (SHRQconst [32] x)
return true
}
}
-func rewriteValueAMD64_OpInterCall(v *Value) bool {
+func rewriteValueAMD64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueAMD64_OpIsInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
return true
}
}
-func rewriteValueAMD64_OpIsNonNil(v *Value) bool {
+func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
return true
}
}
-func rewriteValueAMD64_OpLeq16(v *Value) bool {
+func rewriteValueAMD64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16 x y)
return true
}
}
-func rewriteValueAMD64_OpLeq16U(v *Value) bool {
+func rewriteValueAMD64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq16U x y)
return true
}
}
-func rewriteValueAMD64_OpLeq32(v *Value) bool {
+func rewriteValueAMD64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
return true
}
}
-func rewriteValueAMD64_OpLeq32F(v *Value) bool {
+func rewriteValueAMD64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValueAMD64_OpLeq32U(v *Value) bool {
+func rewriteValueAMD64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
return true
}
}
-func rewriteValueAMD64_OpLeq64(v *Value) bool {
+func rewriteValueAMD64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
return true
}
}
-func rewriteValueAMD64_OpLeq64F(v *Value) bool {
+func rewriteValueAMD64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValueAMD64_OpLeq64U(v *Value) bool {
+func rewriteValueAMD64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
return true
}
}
-func rewriteValueAMD64_OpLeq8(v *Value) bool {
+func rewriteValueAMD64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8 x y)
return true
}
}
-func rewriteValueAMD64_OpLeq8U(v *Value) bool {
+func rewriteValueAMD64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq8U x y)
return true
}
}
-func rewriteValueAMD64_OpLess16(v *Value) bool {
+func rewriteValueAMD64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16 x y)
return true
}
}
-func rewriteValueAMD64_OpLess16U(v *Value) bool {
+func rewriteValueAMD64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less16U x y)
return true
}
}
-func rewriteValueAMD64_OpLess32(v *Value) bool {
+func rewriteValueAMD64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
return true
}
}
-func rewriteValueAMD64_OpLess32F(v *Value) bool {
+func rewriteValueAMD64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValueAMD64_OpLess32U(v *Value) bool {
+func rewriteValueAMD64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
return true
}
}
-func rewriteValueAMD64_OpLess64(v *Value) bool {
+func rewriteValueAMD64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
return true
}
}
-func rewriteValueAMD64_OpLess64F(v *Value) bool {
+func rewriteValueAMD64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValueAMD64_OpLess64U(v *Value) bool {
+func rewriteValueAMD64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
return true
}
}
-func rewriteValueAMD64_OpLess8(v *Value) bool {
+func rewriteValueAMD64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8 x y)
return true
}
}
-func rewriteValueAMD64_OpLess8U(v *Value) bool {
+func rewriteValueAMD64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less8U x y)
return true
}
}
-func rewriteValueAMD64_OpLoad(v *Value) bool {
+func rewriteValueAMD64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpLsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpLsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpMod16(v *Value) bool {
+func rewriteValueAMD64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod16u(v *Value) bool {
+func rewriteValueAMD64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod32(v *Value) bool {
+func rewriteValueAMD64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod32u(v *Value) bool {
+func rewriteValueAMD64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod64(v *Value) bool {
+func rewriteValueAMD64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod64u(v *Value) bool {
+func rewriteValueAMD64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod8(v *Value) bool {
+func rewriteValueAMD64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMod8u(v *Value) bool {
+func rewriteValueAMD64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpMove(v *Value) bool {
+func rewriteValueAMD64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [s] dst src mem)
// cond: s > 8 && s < 16
// result: (MOVQstore [s-8] dst (MOVQload [s-8] src mem) (MOVQstore dst (MOVQload src mem) mem))
}
return false
}
-func rewriteValueAMD64_OpMul16(v *Value) bool {
+func rewriteValueAMD64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValueAMD64_OpMul32(v *Value) bool {
+func rewriteValueAMD64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValueAMD64_OpMul32F(v *Value) bool {
+func rewriteValueAMD64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULSS x y)
return true
}
}
-func rewriteValueAMD64_OpMul64(v *Value) bool {
+func rewriteValueAMD64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULQ x y)
return true
}
}
-func rewriteValueAMD64_OpMul64F(v *Value) bool {
+func rewriteValueAMD64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULSD x y)
return true
}
}
-func rewriteValueAMD64_OpMul64uhilo(v *Value) bool {
+func rewriteValueAMD64_OpMul64uhilo_0(v *Value) bool {
// match: (Mul64uhilo x y)
// cond:
// result: (MULQU2 x y)
return true
}
}
-func rewriteValueAMD64_OpMul8(v *Value) bool {
+func rewriteValueAMD64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULL x y)
return true
}
}
-func rewriteValueAMD64_OpNeg16(v *Value) bool {
+func rewriteValueAMD64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValueAMD64_OpNeg32(v *Value) bool {
+func rewriteValueAMD64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValueAMD64_OpNeg32F(v *Value) bool {
+func rewriteValueAMD64_OpNeg32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpNeg64(v *Value) bool {
+func rewriteValueAMD64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEGQ x)
return true
}
}
-func rewriteValueAMD64_OpNeg64F(v *Value) bool {
+func rewriteValueAMD64_OpNeg64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpNeg8(v *Value) bool {
+func rewriteValueAMD64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGL x)
return true
}
}
-func rewriteValueAMD64_OpNeq16(v *Value) bool {
+func rewriteValueAMD64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x y)
return true
}
}
-func rewriteValueAMD64_OpNeq32(v *Value) bool {
+func rewriteValueAMD64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
return true
}
}
-func rewriteValueAMD64_OpNeq32F(v *Value) bool {
+func rewriteValueAMD64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValueAMD64_OpNeq64(v *Value) bool {
+func rewriteValueAMD64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
return true
}
}
-func rewriteValueAMD64_OpNeq64F(v *Value) bool {
+func rewriteValueAMD64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValueAMD64_OpNeq8(v *Value) bool {
+func rewriteValueAMD64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x y)
return true
}
}
-func rewriteValueAMD64_OpNeqB(v *Value) bool {
+func rewriteValueAMD64_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqB x y)
return true
}
}
-func rewriteValueAMD64_OpNeqPtr(v *Value) bool {
+func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpNilCheck(v *Value) bool {
+func rewriteValueAMD64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueAMD64_OpNot(v *Value) bool {
+func rewriteValueAMD64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORLconst [1] x)
return true
}
}
-func rewriteValueAMD64_OpOffPtr(v *Value) bool {
+func rewriteValueAMD64_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpOr16(v *Value) bool {
+func rewriteValueAMD64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValueAMD64_OpOr32(v *Value) bool {
+func rewriteValueAMD64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValueAMD64_OpOr64(v *Value) bool {
+func rewriteValueAMD64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (ORQ x y)
return true
}
}
-func rewriteValueAMD64_OpOr8(v *Value) bool {
+func rewriteValueAMD64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValueAMD64_OpOrB(v *Value) bool {
+func rewriteValueAMD64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORL x y)
return true
}
}
-func rewriteValueAMD64_OpPopCount16(v *Value) bool {
+func rewriteValueAMD64_OpPopCount16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpPopCount32(v *Value) bool {
+func rewriteValueAMD64_OpPopCount32_0(v *Value) bool {
// match: (PopCount32 x)
// cond:
// result: (POPCNTL x)
return true
}
}
-func rewriteValueAMD64_OpPopCount64(v *Value) bool {
+func rewriteValueAMD64_OpPopCount64_0(v *Value) bool {
// match: (PopCount64 x)
// cond:
// result: (POPCNTQ x)
return true
}
}
-func rewriteValueAMD64_OpPopCount8(v *Value) bool {
+func rewriteValueAMD64_OpPopCount8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueAMD64_OpRound32F(v *Value) bool {
+func rewriteValueAMD64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpRound64F(v *Value) bool {
+func rewriteValueAMD64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh16x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh32x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh64x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8x16(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8x32(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8x64(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x64 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpRsh8x8(v *Value) bool {
+func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x y)
return true
}
}
-func rewriteValueAMD64_OpSelect0(v *Value) bool {
+func rewriteValueAMD64_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
// match: (Select0 <t> (AddTupleFirst32 tuple val))
}
return false
}
-func rewriteValueAMD64_OpSelect1(v *Value) bool {
+func rewriteValueAMD64_OpSelect1_0(v *Value) bool {
// match: (Select1 (AddTupleFirst32 tuple _))
// cond:
// result: (Select1 tuple)
}
return false
}
-func rewriteValueAMD64_OpSignExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVWQSX x)
return true
}
}
-func rewriteValueAMD64_OpSignExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVWQSX x)
return true
}
}
-func rewriteValueAMD64_OpSignExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVLQSX x)
return true
}
}
-func rewriteValueAMD64_OpSignExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBQSX x)
return true
}
}
-func rewriteValueAMD64_OpSignExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBQSX x)
return true
}
}
-func rewriteValueAMD64_OpSignExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBQSX x)
return true
}
}
-func rewriteValueAMD64_OpSlicemask(v *Value) bool {
+func rewriteValueAMD64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueAMD64_OpSqrt(v *Value) bool {
+func rewriteValueAMD64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTSD x)
return true
}
}
-func rewriteValueAMD64_OpStaticCall(v *Value) bool {
+func rewriteValueAMD64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueAMD64_OpStore(v *Value) bool {
+func rewriteValueAMD64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (MOVSDstore ptr val mem)
}
return false
}
-func rewriteValueAMD64_OpSub16(v *Value) bool {
+func rewriteValueAMD64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValueAMD64_OpSub32(v *Value) bool {
+func rewriteValueAMD64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValueAMD64_OpSub32F(v *Value) bool {
+func rewriteValueAMD64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBSS x y)
return true
}
}
-func rewriteValueAMD64_OpSub64(v *Value) bool {
+func rewriteValueAMD64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUBQ x y)
return true
}
}
-func rewriteValueAMD64_OpSub64F(v *Value) bool {
+func rewriteValueAMD64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBSD x y)
return true
}
}
-func rewriteValueAMD64_OpSub8(v *Value) bool {
+func rewriteValueAMD64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBL x y)
return true
}
}
-func rewriteValueAMD64_OpSubPtr(v *Value) bool {
+func rewriteValueAMD64_OpSubPtr_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueAMD64_OpTrunc16to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpTrunc32to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpTrunc32to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpTrunc64to16(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpTrunc64to32(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpTrunc64to8(v *Value) bool {
+func rewriteValueAMD64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueAMD64_OpXor16(v *Value) bool {
+func rewriteValueAMD64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValueAMD64_OpXor32(v *Value) bool {
+func rewriteValueAMD64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValueAMD64_OpXor64(v *Value) bool {
+func rewriteValueAMD64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XORQ x y)
return true
}
}
-func rewriteValueAMD64_OpXor8(v *Value) bool {
+func rewriteValueAMD64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORL x y)
return true
}
}
-func rewriteValueAMD64_OpZero(v *Value) bool {
+func rewriteValueAMD64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
- types := &b.Func.Config.Types
- _ = types
// match: (Zero [0] _ mem)
// cond:
// result: mem
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueAMD64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [16] destptr mem)
// cond:
// result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem))
}
return false
}
-func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVWQZX x)
return true
}
}
-func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVWQZX x)
return true
}
}
-func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVLQZX x)
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBQZX x)
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBQZX x)
return true
}
}
-func rewriteValueAMD64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueAMD64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBQZX x)
func rewriteValueARM(v *Value) bool {
switch v.Op {
case OpARMADC:
- return rewriteValueARM_OpARMADC(v)
+ return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v)
case OpARMADCconst:
- return rewriteValueARM_OpARMADCconst(v)
+ return rewriteValueARM_OpARMADCconst_0(v)
case OpARMADCshiftLL:
- return rewriteValueARM_OpARMADCshiftLL(v)
+ return rewriteValueARM_OpARMADCshiftLL_0(v)
case OpARMADCshiftLLreg:
- return rewriteValueARM_OpARMADCshiftLLreg(v)
+ return rewriteValueARM_OpARMADCshiftLLreg_0(v)
case OpARMADCshiftRA:
- return rewriteValueARM_OpARMADCshiftRA(v)
+ return rewriteValueARM_OpARMADCshiftRA_0(v)
case OpARMADCshiftRAreg:
- return rewriteValueARM_OpARMADCshiftRAreg(v)
+ return rewriteValueARM_OpARMADCshiftRAreg_0(v)
case OpARMADCshiftRL:
- return rewriteValueARM_OpARMADCshiftRL(v)
+ return rewriteValueARM_OpARMADCshiftRL_0(v)
case OpARMADCshiftRLreg:
- return rewriteValueARM_OpARMADCshiftRLreg(v)
+ return rewriteValueARM_OpARMADCshiftRLreg_0(v)
case OpARMADD:
- return rewriteValueARM_OpARMADD(v)
+ return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v)
case OpARMADDS:
- return rewriteValueARM_OpARMADDS(v)
+ return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v)
case OpARMADDSshiftLL:
- return rewriteValueARM_OpARMADDSshiftLL(v)
+ return rewriteValueARM_OpARMADDSshiftLL_0(v)
case OpARMADDSshiftLLreg:
- return rewriteValueARM_OpARMADDSshiftLLreg(v)
+ return rewriteValueARM_OpARMADDSshiftLLreg_0(v)
case OpARMADDSshiftRA:
- return rewriteValueARM_OpARMADDSshiftRA(v)
+ return rewriteValueARM_OpARMADDSshiftRA_0(v)
case OpARMADDSshiftRAreg:
- return rewriteValueARM_OpARMADDSshiftRAreg(v)
+ return rewriteValueARM_OpARMADDSshiftRAreg_0(v)
case OpARMADDSshiftRL:
- return rewriteValueARM_OpARMADDSshiftRL(v)
+ return rewriteValueARM_OpARMADDSshiftRL_0(v)
case OpARMADDSshiftRLreg:
- return rewriteValueARM_OpARMADDSshiftRLreg(v)
+ return rewriteValueARM_OpARMADDSshiftRLreg_0(v)
case OpARMADDconst:
- return rewriteValueARM_OpARMADDconst(v)
+ return rewriteValueARM_OpARMADDconst_0(v)
case OpARMADDshiftLL:
- return rewriteValueARM_OpARMADDshiftLL(v)
+ return rewriteValueARM_OpARMADDshiftLL_0(v)
case OpARMADDshiftLLreg:
- return rewriteValueARM_OpARMADDshiftLLreg(v)
+ return rewriteValueARM_OpARMADDshiftLLreg_0(v)
case OpARMADDshiftRA:
- return rewriteValueARM_OpARMADDshiftRA(v)
+ return rewriteValueARM_OpARMADDshiftRA_0(v)
case OpARMADDshiftRAreg:
- return rewriteValueARM_OpARMADDshiftRAreg(v)
+ return rewriteValueARM_OpARMADDshiftRAreg_0(v)
case OpARMADDshiftRL:
- return rewriteValueARM_OpARMADDshiftRL(v)
+ return rewriteValueARM_OpARMADDshiftRL_0(v)
case OpARMADDshiftRLreg:
- return rewriteValueARM_OpARMADDshiftRLreg(v)
+ return rewriteValueARM_OpARMADDshiftRLreg_0(v)
case OpARMAND:
- return rewriteValueARM_OpARMAND(v)
+ return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v)
case OpARMANDconst:
- return rewriteValueARM_OpARMANDconst(v)
+ return rewriteValueARM_OpARMANDconst_0(v)
case OpARMANDshiftLL:
- return rewriteValueARM_OpARMANDshiftLL(v)
+ return rewriteValueARM_OpARMANDshiftLL_0(v)
case OpARMANDshiftLLreg:
- return rewriteValueARM_OpARMANDshiftLLreg(v)
+ return rewriteValueARM_OpARMANDshiftLLreg_0(v)
case OpARMANDshiftRA:
- return rewriteValueARM_OpARMANDshiftRA(v)
+ return rewriteValueARM_OpARMANDshiftRA_0(v)
case OpARMANDshiftRAreg:
- return rewriteValueARM_OpARMANDshiftRAreg(v)
+ return rewriteValueARM_OpARMANDshiftRAreg_0(v)
case OpARMANDshiftRL:
- return rewriteValueARM_OpARMANDshiftRL(v)
+ return rewriteValueARM_OpARMANDshiftRL_0(v)
case OpARMANDshiftRLreg:
- return rewriteValueARM_OpARMANDshiftRLreg(v)
+ return rewriteValueARM_OpARMANDshiftRLreg_0(v)
case OpARMBIC:
- return rewriteValueARM_OpARMBIC(v)
+ return rewriteValueARM_OpARMBIC_0(v)
case OpARMBICconst:
- return rewriteValueARM_OpARMBICconst(v)
+ return rewriteValueARM_OpARMBICconst_0(v)
case OpARMBICshiftLL:
- return rewriteValueARM_OpARMBICshiftLL(v)
+ return rewriteValueARM_OpARMBICshiftLL_0(v)
case OpARMBICshiftLLreg:
- return rewriteValueARM_OpARMBICshiftLLreg(v)
+ return rewriteValueARM_OpARMBICshiftLLreg_0(v)
case OpARMBICshiftRA:
- return rewriteValueARM_OpARMBICshiftRA(v)
+ return rewriteValueARM_OpARMBICshiftRA_0(v)
case OpARMBICshiftRAreg:
- return rewriteValueARM_OpARMBICshiftRAreg(v)
+ return rewriteValueARM_OpARMBICshiftRAreg_0(v)
case OpARMBICshiftRL:
- return rewriteValueARM_OpARMBICshiftRL(v)
+ return rewriteValueARM_OpARMBICshiftRL_0(v)
case OpARMBICshiftRLreg:
- return rewriteValueARM_OpARMBICshiftRLreg(v)
+ return rewriteValueARM_OpARMBICshiftRLreg_0(v)
case OpARMCMOVWHSconst:
- return rewriteValueARM_OpARMCMOVWHSconst(v)
+ return rewriteValueARM_OpARMCMOVWHSconst_0(v)
case OpARMCMOVWLSconst:
- return rewriteValueARM_OpARMCMOVWLSconst(v)
+ return rewriteValueARM_OpARMCMOVWLSconst_0(v)
case OpARMCMP:
- return rewriteValueARM_OpARMCMP(v)
+ return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v)
case OpARMCMPD:
- return rewriteValueARM_OpARMCMPD(v)
+ return rewriteValueARM_OpARMCMPD_0(v)
case OpARMCMPF:
- return rewriteValueARM_OpARMCMPF(v)
+ return rewriteValueARM_OpARMCMPF_0(v)
case OpARMCMPconst:
- return rewriteValueARM_OpARMCMPconst(v)
+ return rewriteValueARM_OpARMCMPconst_0(v)
case OpARMCMPshiftLL:
- return rewriteValueARM_OpARMCMPshiftLL(v)
+ return rewriteValueARM_OpARMCMPshiftLL_0(v)
case OpARMCMPshiftLLreg:
- return rewriteValueARM_OpARMCMPshiftLLreg(v)
+ return rewriteValueARM_OpARMCMPshiftLLreg_0(v)
case OpARMCMPshiftRA:
- return rewriteValueARM_OpARMCMPshiftRA(v)
+ return rewriteValueARM_OpARMCMPshiftRA_0(v)
case OpARMCMPshiftRAreg:
- return rewriteValueARM_OpARMCMPshiftRAreg(v)
+ return rewriteValueARM_OpARMCMPshiftRAreg_0(v)
case OpARMCMPshiftRL:
- return rewriteValueARM_OpARMCMPshiftRL(v)
+ return rewriteValueARM_OpARMCMPshiftRL_0(v)
case OpARMCMPshiftRLreg:
- return rewriteValueARM_OpARMCMPshiftRLreg(v)
+ return rewriteValueARM_OpARMCMPshiftRLreg_0(v)
case OpARMEqual:
- return rewriteValueARM_OpARMEqual(v)
+ return rewriteValueARM_OpARMEqual_0(v)
case OpARMGreaterEqual:
- return rewriteValueARM_OpARMGreaterEqual(v)
+ return rewriteValueARM_OpARMGreaterEqual_0(v)
case OpARMGreaterEqualU:
- return rewriteValueARM_OpARMGreaterEqualU(v)
+ return rewriteValueARM_OpARMGreaterEqualU_0(v)
case OpARMGreaterThan:
- return rewriteValueARM_OpARMGreaterThan(v)
+ return rewriteValueARM_OpARMGreaterThan_0(v)
case OpARMGreaterThanU:
- return rewriteValueARM_OpARMGreaterThanU(v)
+ return rewriteValueARM_OpARMGreaterThanU_0(v)
case OpARMLessEqual:
- return rewriteValueARM_OpARMLessEqual(v)
+ return rewriteValueARM_OpARMLessEqual_0(v)
case OpARMLessEqualU:
- return rewriteValueARM_OpARMLessEqualU(v)
+ return rewriteValueARM_OpARMLessEqualU_0(v)
case OpARMLessThan:
- return rewriteValueARM_OpARMLessThan(v)
+ return rewriteValueARM_OpARMLessThan_0(v)
case OpARMLessThanU:
- return rewriteValueARM_OpARMLessThanU(v)
+ return rewriteValueARM_OpARMLessThanU_0(v)
case OpARMMOVBUload:
- return rewriteValueARM_OpARMMOVBUload(v)
+ return rewriteValueARM_OpARMMOVBUload_0(v)
case OpARMMOVBUreg:
- return rewriteValueARM_OpARMMOVBUreg(v)
+ return rewriteValueARM_OpARMMOVBUreg_0(v)
case OpARMMOVBload:
- return rewriteValueARM_OpARMMOVBload(v)
+ return rewriteValueARM_OpARMMOVBload_0(v)
case OpARMMOVBreg:
- return rewriteValueARM_OpARMMOVBreg(v)
+ return rewriteValueARM_OpARMMOVBreg_0(v)
case OpARMMOVBstore:
- return rewriteValueARM_OpARMMOVBstore(v)
+ return rewriteValueARM_OpARMMOVBstore_0(v)
case OpARMMOVDload:
- return rewriteValueARM_OpARMMOVDload(v)
+ return rewriteValueARM_OpARMMOVDload_0(v)
case OpARMMOVDstore:
- return rewriteValueARM_OpARMMOVDstore(v)
+ return rewriteValueARM_OpARMMOVDstore_0(v)
case OpARMMOVFload:
- return rewriteValueARM_OpARMMOVFload(v)
+ return rewriteValueARM_OpARMMOVFload_0(v)
case OpARMMOVFstore:
- return rewriteValueARM_OpARMMOVFstore(v)
+ return rewriteValueARM_OpARMMOVFstore_0(v)
case OpARMMOVHUload:
- return rewriteValueARM_OpARMMOVHUload(v)
+ return rewriteValueARM_OpARMMOVHUload_0(v)
case OpARMMOVHUreg:
- return rewriteValueARM_OpARMMOVHUreg(v)
+ return rewriteValueARM_OpARMMOVHUreg_0(v)
case OpARMMOVHload:
- return rewriteValueARM_OpARMMOVHload(v)
+ return rewriteValueARM_OpARMMOVHload_0(v)
case OpARMMOVHreg:
- return rewriteValueARM_OpARMMOVHreg(v)
+ return rewriteValueARM_OpARMMOVHreg_0(v)
case OpARMMOVHstore:
- return rewriteValueARM_OpARMMOVHstore(v)
+ return rewriteValueARM_OpARMMOVHstore_0(v)
case OpARMMOVWload:
- return rewriteValueARM_OpARMMOVWload(v)
+ return rewriteValueARM_OpARMMOVWload_0(v)
case OpARMMOVWloadidx:
- return rewriteValueARM_OpARMMOVWloadidx(v)
+ return rewriteValueARM_OpARMMOVWloadidx_0(v)
case OpARMMOVWloadshiftLL:
- return rewriteValueARM_OpARMMOVWloadshiftLL(v)
+ return rewriteValueARM_OpARMMOVWloadshiftLL_0(v)
case OpARMMOVWloadshiftRA:
- return rewriteValueARM_OpARMMOVWloadshiftRA(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRA_0(v)
case OpARMMOVWloadshiftRL:
- return rewriteValueARM_OpARMMOVWloadshiftRL(v)
+ return rewriteValueARM_OpARMMOVWloadshiftRL_0(v)
case OpARMMOVWreg:
- return rewriteValueARM_OpARMMOVWreg(v)
+ return rewriteValueARM_OpARMMOVWreg_0(v)
case OpARMMOVWstore:
- return rewriteValueARM_OpARMMOVWstore(v)
+ return rewriteValueARM_OpARMMOVWstore_0(v)
case OpARMMOVWstoreidx:
- return rewriteValueARM_OpARMMOVWstoreidx(v)
+ return rewriteValueARM_OpARMMOVWstoreidx_0(v)
case OpARMMOVWstoreshiftLL:
- return rewriteValueARM_OpARMMOVWstoreshiftLL(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v)
case OpARMMOVWstoreshiftRA:
- return rewriteValueARM_OpARMMOVWstoreshiftRA(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v)
case OpARMMOVWstoreshiftRL:
- return rewriteValueARM_OpARMMOVWstoreshiftRL(v)
+ return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v)
case OpARMMUL:
- return rewriteValueARM_OpARMMUL(v)
+ return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v)
case OpARMMULA:
- return rewriteValueARM_OpARMMULA(v)
+ return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v)
case OpARMMVN:
- return rewriteValueARM_OpARMMVN(v)
+ return rewriteValueARM_OpARMMVN_0(v)
case OpARMMVNshiftLL:
- return rewriteValueARM_OpARMMVNshiftLL(v)
+ return rewriteValueARM_OpARMMVNshiftLL_0(v)
case OpARMMVNshiftLLreg:
- return rewriteValueARM_OpARMMVNshiftLLreg(v)
+ return rewriteValueARM_OpARMMVNshiftLLreg_0(v)
case OpARMMVNshiftRA:
- return rewriteValueARM_OpARMMVNshiftRA(v)
+ return rewriteValueARM_OpARMMVNshiftRA_0(v)
case OpARMMVNshiftRAreg:
- return rewriteValueARM_OpARMMVNshiftRAreg(v)
+ return rewriteValueARM_OpARMMVNshiftRAreg_0(v)
case OpARMMVNshiftRL:
- return rewriteValueARM_OpARMMVNshiftRL(v)
+ return rewriteValueARM_OpARMMVNshiftRL_0(v)
case OpARMMVNshiftRLreg:
- return rewriteValueARM_OpARMMVNshiftRLreg(v)
+ return rewriteValueARM_OpARMMVNshiftRLreg_0(v)
case OpARMNotEqual:
- return rewriteValueARM_OpARMNotEqual(v)
+ return rewriteValueARM_OpARMNotEqual_0(v)
case OpARMOR:
- return rewriteValueARM_OpARMOR(v)
+ return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v)
case OpARMORconst:
- return rewriteValueARM_OpARMORconst(v)
+ return rewriteValueARM_OpARMORconst_0(v)
case OpARMORshiftLL:
- return rewriteValueARM_OpARMORshiftLL(v)
+ return rewriteValueARM_OpARMORshiftLL_0(v)
case OpARMORshiftLLreg:
- return rewriteValueARM_OpARMORshiftLLreg(v)
+ return rewriteValueARM_OpARMORshiftLLreg_0(v)
case OpARMORshiftRA:
- return rewriteValueARM_OpARMORshiftRA(v)
+ return rewriteValueARM_OpARMORshiftRA_0(v)
case OpARMORshiftRAreg:
- return rewriteValueARM_OpARMORshiftRAreg(v)
+ return rewriteValueARM_OpARMORshiftRAreg_0(v)
case OpARMORshiftRL:
- return rewriteValueARM_OpARMORshiftRL(v)
+ return rewriteValueARM_OpARMORshiftRL_0(v)
case OpARMORshiftRLreg:
- return rewriteValueARM_OpARMORshiftRLreg(v)
+ return rewriteValueARM_OpARMORshiftRLreg_0(v)
case OpARMRSB:
- return rewriteValueARM_OpARMRSB(v)
+ return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v)
case OpARMRSBSshiftLL:
- return rewriteValueARM_OpARMRSBSshiftLL(v)
+ return rewriteValueARM_OpARMRSBSshiftLL_0(v)
case OpARMRSBSshiftLLreg:
- return rewriteValueARM_OpARMRSBSshiftLLreg(v)
+ return rewriteValueARM_OpARMRSBSshiftLLreg_0(v)
case OpARMRSBSshiftRA:
- return rewriteValueARM_OpARMRSBSshiftRA(v)
+ return rewriteValueARM_OpARMRSBSshiftRA_0(v)
case OpARMRSBSshiftRAreg:
- return rewriteValueARM_OpARMRSBSshiftRAreg(v)
+ return rewriteValueARM_OpARMRSBSshiftRAreg_0(v)
case OpARMRSBSshiftRL:
- return rewriteValueARM_OpARMRSBSshiftRL(v)
+ return rewriteValueARM_OpARMRSBSshiftRL_0(v)
case OpARMRSBSshiftRLreg:
- return rewriteValueARM_OpARMRSBSshiftRLreg(v)
+ return rewriteValueARM_OpARMRSBSshiftRLreg_0(v)
case OpARMRSBconst:
- return rewriteValueARM_OpARMRSBconst(v)
+ return rewriteValueARM_OpARMRSBconst_0(v)
case OpARMRSBshiftLL:
- return rewriteValueARM_OpARMRSBshiftLL(v)
+ return rewriteValueARM_OpARMRSBshiftLL_0(v)
case OpARMRSBshiftLLreg:
- return rewriteValueARM_OpARMRSBshiftLLreg(v)
+ return rewriteValueARM_OpARMRSBshiftLLreg_0(v)
case OpARMRSBshiftRA:
- return rewriteValueARM_OpARMRSBshiftRA(v)
+ return rewriteValueARM_OpARMRSBshiftRA_0(v)
case OpARMRSBshiftRAreg:
- return rewriteValueARM_OpARMRSBshiftRAreg(v)
+ return rewriteValueARM_OpARMRSBshiftRAreg_0(v)
case OpARMRSBshiftRL:
- return rewriteValueARM_OpARMRSBshiftRL(v)
+ return rewriteValueARM_OpARMRSBshiftRL_0(v)
case OpARMRSBshiftRLreg:
- return rewriteValueARM_OpARMRSBshiftRLreg(v)
+ return rewriteValueARM_OpARMRSBshiftRLreg_0(v)
case OpARMRSCconst:
- return rewriteValueARM_OpARMRSCconst(v)
+ return rewriteValueARM_OpARMRSCconst_0(v)
case OpARMRSCshiftLL:
- return rewriteValueARM_OpARMRSCshiftLL(v)
+ return rewriteValueARM_OpARMRSCshiftLL_0(v)
case OpARMRSCshiftLLreg:
- return rewriteValueARM_OpARMRSCshiftLLreg(v)
+ return rewriteValueARM_OpARMRSCshiftLLreg_0(v)
case OpARMRSCshiftRA:
- return rewriteValueARM_OpARMRSCshiftRA(v)
+ return rewriteValueARM_OpARMRSCshiftRA_0(v)
case OpARMRSCshiftRAreg:
- return rewriteValueARM_OpARMRSCshiftRAreg(v)
+ return rewriteValueARM_OpARMRSCshiftRAreg_0(v)
case OpARMRSCshiftRL:
- return rewriteValueARM_OpARMRSCshiftRL(v)
+ return rewriteValueARM_OpARMRSCshiftRL_0(v)
case OpARMRSCshiftRLreg:
- return rewriteValueARM_OpARMRSCshiftRLreg(v)
+ return rewriteValueARM_OpARMRSCshiftRLreg_0(v)
case OpARMSBC:
- return rewriteValueARM_OpARMSBC(v)
+ return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v)
case OpARMSBCconst:
- return rewriteValueARM_OpARMSBCconst(v)
+ return rewriteValueARM_OpARMSBCconst_0(v)
case OpARMSBCshiftLL:
- return rewriteValueARM_OpARMSBCshiftLL(v)
+ return rewriteValueARM_OpARMSBCshiftLL_0(v)
case OpARMSBCshiftLLreg:
- return rewriteValueARM_OpARMSBCshiftLLreg(v)
+ return rewriteValueARM_OpARMSBCshiftLLreg_0(v)
case OpARMSBCshiftRA:
- return rewriteValueARM_OpARMSBCshiftRA(v)
+ return rewriteValueARM_OpARMSBCshiftRA_0(v)
case OpARMSBCshiftRAreg:
- return rewriteValueARM_OpARMSBCshiftRAreg(v)
+ return rewriteValueARM_OpARMSBCshiftRAreg_0(v)
case OpARMSBCshiftRL:
- return rewriteValueARM_OpARMSBCshiftRL(v)
+ return rewriteValueARM_OpARMSBCshiftRL_0(v)
case OpARMSBCshiftRLreg:
- return rewriteValueARM_OpARMSBCshiftRLreg(v)
+ return rewriteValueARM_OpARMSBCshiftRLreg_0(v)
case OpARMSLL:
- return rewriteValueARM_OpARMSLL(v)
+ return rewriteValueARM_OpARMSLL_0(v)
case OpARMSLLconst:
- return rewriteValueARM_OpARMSLLconst(v)
+ return rewriteValueARM_OpARMSLLconst_0(v)
case OpARMSRA:
- return rewriteValueARM_OpARMSRA(v)
+ return rewriteValueARM_OpARMSRA_0(v)
case OpARMSRAcond:
- return rewriteValueARM_OpARMSRAcond(v)
+ return rewriteValueARM_OpARMSRAcond_0(v)
case OpARMSRAconst:
- return rewriteValueARM_OpARMSRAconst(v)
+ return rewriteValueARM_OpARMSRAconst_0(v)
case OpARMSRL:
- return rewriteValueARM_OpARMSRL(v)
+ return rewriteValueARM_OpARMSRL_0(v)
case OpARMSRLconst:
- return rewriteValueARM_OpARMSRLconst(v)
+ return rewriteValueARM_OpARMSRLconst_0(v)
case OpARMSUB:
- return rewriteValueARM_OpARMSUB(v)
+ return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v)
case OpARMSUBS:
- return rewriteValueARM_OpARMSUBS(v)
+ return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v)
case OpARMSUBSshiftLL:
- return rewriteValueARM_OpARMSUBSshiftLL(v)
+ return rewriteValueARM_OpARMSUBSshiftLL_0(v)
case OpARMSUBSshiftLLreg:
- return rewriteValueARM_OpARMSUBSshiftLLreg(v)
+ return rewriteValueARM_OpARMSUBSshiftLLreg_0(v)
case OpARMSUBSshiftRA:
- return rewriteValueARM_OpARMSUBSshiftRA(v)
+ return rewriteValueARM_OpARMSUBSshiftRA_0(v)
case OpARMSUBSshiftRAreg:
- return rewriteValueARM_OpARMSUBSshiftRAreg(v)
+ return rewriteValueARM_OpARMSUBSshiftRAreg_0(v)
case OpARMSUBSshiftRL:
- return rewriteValueARM_OpARMSUBSshiftRL(v)
+ return rewriteValueARM_OpARMSUBSshiftRL_0(v)
case OpARMSUBSshiftRLreg:
- return rewriteValueARM_OpARMSUBSshiftRLreg(v)
+ return rewriteValueARM_OpARMSUBSshiftRLreg_0(v)
case OpARMSUBconst:
- return rewriteValueARM_OpARMSUBconst(v)
+ return rewriteValueARM_OpARMSUBconst_0(v)
case OpARMSUBshiftLL:
- return rewriteValueARM_OpARMSUBshiftLL(v)
+ return rewriteValueARM_OpARMSUBshiftLL_0(v)
case OpARMSUBshiftLLreg:
- return rewriteValueARM_OpARMSUBshiftLLreg(v)
+ return rewriteValueARM_OpARMSUBshiftLLreg_0(v)
case OpARMSUBshiftRA:
- return rewriteValueARM_OpARMSUBshiftRA(v)
+ return rewriteValueARM_OpARMSUBshiftRA_0(v)
case OpARMSUBshiftRAreg:
- return rewriteValueARM_OpARMSUBshiftRAreg(v)
+ return rewriteValueARM_OpARMSUBshiftRAreg_0(v)
case OpARMSUBshiftRL:
- return rewriteValueARM_OpARMSUBshiftRL(v)
+ return rewriteValueARM_OpARMSUBshiftRL_0(v)
case OpARMSUBshiftRLreg:
- return rewriteValueARM_OpARMSUBshiftRLreg(v)
+ return rewriteValueARM_OpARMSUBshiftRLreg_0(v)
case OpARMXOR:
- return rewriteValueARM_OpARMXOR(v)
+ return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v)
case OpARMXORconst:
- return rewriteValueARM_OpARMXORconst(v)
+ return rewriteValueARM_OpARMXORconst_0(v)
case OpARMXORshiftLL:
- return rewriteValueARM_OpARMXORshiftLL(v)
+ return rewriteValueARM_OpARMXORshiftLL_0(v)
case OpARMXORshiftLLreg:
- return rewriteValueARM_OpARMXORshiftLLreg(v)
+ return rewriteValueARM_OpARMXORshiftLLreg_0(v)
case OpARMXORshiftRA:
- return rewriteValueARM_OpARMXORshiftRA(v)
+ return rewriteValueARM_OpARMXORshiftRA_0(v)
case OpARMXORshiftRAreg:
- return rewriteValueARM_OpARMXORshiftRAreg(v)
+ return rewriteValueARM_OpARMXORshiftRAreg_0(v)
case OpARMXORshiftRL:
- return rewriteValueARM_OpARMXORshiftRL(v)
+ return rewriteValueARM_OpARMXORshiftRL_0(v)
case OpARMXORshiftRLreg:
- return rewriteValueARM_OpARMXORshiftRLreg(v)
+ return rewriteValueARM_OpARMXORshiftRLreg_0(v)
case OpARMXORshiftRR:
- return rewriteValueARM_OpARMXORshiftRR(v)
+ return rewriteValueARM_OpARMXORshiftRR_0(v)
case OpAdd16:
- return rewriteValueARM_OpAdd16(v)
+ return rewriteValueARM_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueARM_OpAdd32(v)
+ return rewriteValueARM_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueARM_OpAdd32F(v)
+ return rewriteValueARM_OpAdd32F_0(v)
case OpAdd32carry:
- return rewriteValueARM_OpAdd32carry(v)
+ return rewriteValueARM_OpAdd32carry_0(v)
case OpAdd32withcarry:
- return rewriteValueARM_OpAdd32withcarry(v)
+ return rewriteValueARM_OpAdd32withcarry_0(v)
case OpAdd64F:
- return rewriteValueARM_OpAdd64F(v)
+ return rewriteValueARM_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueARM_OpAdd8(v)
+ return rewriteValueARM_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueARM_OpAddPtr(v)
+ return rewriteValueARM_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueARM_OpAddr(v)
+ return rewriteValueARM_OpAddr_0(v)
case OpAnd16:
- return rewriteValueARM_OpAnd16(v)
+ return rewriteValueARM_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueARM_OpAnd32(v)
+ return rewriteValueARM_OpAnd32_0(v)
case OpAnd8:
- return rewriteValueARM_OpAnd8(v)
+ return rewriteValueARM_OpAnd8_0(v)
case OpAndB:
- return rewriteValueARM_OpAndB(v)
+ return rewriteValueARM_OpAndB_0(v)
case OpAvg32u:
- return rewriteValueARM_OpAvg32u(v)
+ return rewriteValueARM_OpAvg32u_0(v)
case OpBitLen32:
- return rewriteValueARM_OpBitLen32(v)
+ return rewriteValueARM_OpBitLen32_0(v)
case OpBswap32:
- return rewriteValueARM_OpBswap32(v)
+ return rewriteValueARM_OpBswap32_0(v)
case OpClosureCall:
- return rewriteValueARM_OpClosureCall(v)
+ return rewriteValueARM_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueARM_OpCom16(v)
+ return rewriteValueARM_OpCom16_0(v)
case OpCom32:
- return rewriteValueARM_OpCom32(v)
+ return rewriteValueARM_OpCom32_0(v)
case OpCom8:
- return rewriteValueARM_OpCom8(v)
+ return rewriteValueARM_OpCom8_0(v)
case OpConst16:
- return rewriteValueARM_OpConst16(v)
+ return rewriteValueARM_OpConst16_0(v)
case OpConst32:
- return rewriteValueARM_OpConst32(v)
+ return rewriteValueARM_OpConst32_0(v)
case OpConst32F:
- return rewriteValueARM_OpConst32F(v)
+ return rewriteValueARM_OpConst32F_0(v)
case OpConst64F:
- return rewriteValueARM_OpConst64F(v)
+ return rewriteValueARM_OpConst64F_0(v)
case OpConst8:
- return rewriteValueARM_OpConst8(v)
+ return rewriteValueARM_OpConst8_0(v)
case OpConstBool:
- return rewriteValueARM_OpConstBool(v)
+ return rewriteValueARM_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueARM_OpConstNil(v)
+ return rewriteValueARM_OpConstNil_0(v)
case OpConvert:
- return rewriteValueARM_OpConvert(v)
+ return rewriteValueARM_OpConvert_0(v)
case OpCtz32:
- return rewriteValueARM_OpCtz32(v)
+ return rewriteValueARM_OpCtz32_0(v)
case OpCvt32Fto32:
- return rewriteValueARM_OpCvt32Fto32(v)
+ return rewriteValueARM_OpCvt32Fto32_0(v)
case OpCvt32Fto32U:
- return rewriteValueARM_OpCvt32Fto32U(v)
+ return rewriteValueARM_OpCvt32Fto32U_0(v)
case OpCvt32Fto64F:
- return rewriteValueARM_OpCvt32Fto64F(v)
+ return rewriteValueARM_OpCvt32Fto64F_0(v)
case OpCvt32Uto32F:
- return rewriteValueARM_OpCvt32Uto32F(v)
+ return rewriteValueARM_OpCvt32Uto32F_0(v)
case OpCvt32Uto64F:
- return rewriteValueARM_OpCvt32Uto64F(v)
+ return rewriteValueARM_OpCvt32Uto64F_0(v)
case OpCvt32to32F:
- return rewriteValueARM_OpCvt32to32F(v)
+ return rewriteValueARM_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueARM_OpCvt32to64F(v)
+ return rewriteValueARM_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueARM_OpCvt64Fto32(v)
+ return rewriteValueARM_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueARM_OpCvt64Fto32F(v)
+ return rewriteValueARM_OpCvt64Fto32F_0(v)
case OpCvt64Fto32U:
- return rewriteValueARM_OpCvt64Fto32U(v)
+ return rewriteValueARM_OpCvt64Fto32U_0(v)
case OpDiv16:
- return rewriteValueARM_OpDiv16(v)
+ return rewriteValueARM_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueARM_OpDiv16u(v)
+ return rewriteValueARM_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueARM_OpDiv32(v)
+ return rewriteValueARM_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueARM_OpDiv32F(v)
+ return rewriteValueARM_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueARM_OpDiv32u(v)
+ return rewriteValueARM_OpDiv32u_0(v)
case OpDiv64F:
- return rewriteValueARM_OpDiv64F(v)
+ return rewriteValueARM_OpDiv64F_0(v)
case OpDiv8:
- return rewriteValueARM_OpDiv8(v)
+ return rewriteValueARM_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueARM_OpDiv8u(v)
+ return rewriteValueARM_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueARM_OpEq16(v)
+ return rewriteValueARM_OpEq16_0(v)
case OpEq32:
- return rewriteValueARM_OpEq32(v)
+ return rewriteValueARM_OpEq32_0(v)
case OpEq32F:
- return rewriteValueARM_OpEq32F(v)
+ return rewriteValueARM_OpEq32F_0(v)
case OpEq64F:
- return rewriteValueARM_OpEq64F(v)
+ return rewriteValueARM_OpEq64F_0(v)
case OpEq8:
- return rewriteValueARM_OpEq8(v)
+ return rewriteValueARM_OpEq8_0(v)
case OpEqB:
- return rewriteValueARM_OpEqB(v)
+ return rewriteValueARM_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueARM_OpEqPtr(v)
+ return rewriteValueARM_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueARM_OpGeq16(v)
+ return rewriteValueARM_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueARM_OpGeq16U(v)
+ return rewriteValueARM_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueARM_OpGeq32(v)
+ return rewriteValueARM_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueARM_OpGeq32F(v)
+ return rewriteValueARM_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueARM_OpGeq32U(v)
+ return rewriteValueARM_OpGeq32U_0(v)
case OpGeq64F:
- return rewriteValueARM_OpGeq64F(v)
+ return rewriteValueARM_OpGeq64F_0(v)
case OpGeq8:
- return rewriteValueARM_OpGeq8(v)
+ return rewriteValueARM_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueARM_OpGeq8U(v)
+ return rewriteValueARM_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueARM_OpGetClosurePtr(v)
+ return rewriteValueARM_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueARM_OpGreater16(v)
+ return rewriteValueARM_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueARM_OpGreater16U(v)
+ return rewriteValueARM_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueARM_OpGreater32(v)
+ return rewriteValueARM_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueARM_OpGreater32F(v)
+ return rewriteValueARM_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueARM_OpGreater32U(v)
+ return rewriteValueARM_OpGreater32U_0(v)
case OpGreater64F:
- return rewriteValueARM_OpGreater64F(v)
+ return rewriteValueARM_OpGreater64F_0(v)
case OpGreater8:
- return rewriteValueARM_OpGreater8(v)
+ return rewriteValueARM_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueARM_OpGreater8U(v)
+ return rewriteValueARM_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueARM_OpHmul32(v)
+ return rewriteValueARM_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueARM_OpHmul32u(v)
+ return rewriteValueARM_OpHmul32u_0(v)
case OpInterCall:
- return rewriteValueARM_OpInterCall(v)
+ return rewriteValueARM_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueARM_OpIsInBounds(v)
+ return rewriteValueARM_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueARM_OpIsNonNil(v)
+ return rewriteValueARM_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueARM_OpIsSliceInBounds(v)
+ return rewriteValueARM_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueARM_OpLeq16(v)
+ return rewriteValueARM_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueARM_OpLeq16U(v)
+ return rewriteValueARM_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueARM_OpLeq32(v)
+ return rewriteValueARM_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueARM_OpLeq32F(v)
+ return rewriteValueARM_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueARM_OpLeq32U(v)
+ return rewriteValueARM_OpLeq32U_0(v)
case OpLeq64F:
- return rewriteValueARM_OpLeq64F(v)
+ return rewriteValueARM_OpLeq64F_0(v)
case OpLeq8:
- return rewriteValueARM_OpLeq8(v)
+ return rewriteValueARM_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueARM_OpLeq8U(v)
+ return rewriteValueARM_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueARM_OpLess16(v)
+ return rewriteValueARM_OpLess16_0(v)
case OpLess16U:
- return rewriteValueARM_OpLess16U(v)
+ return rewriteValueARM_OpLess16U_0(v)
case OpLess32:
- return rewriteValueARM_OpLess32(v)
+ return rewriteValueARM_OpLess32_0(v)
case OpLess32F:
- return rewriteValueARM_OpLess32F(v)
+ return rewriteValueARM_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueARM_OpLess32U(v)
+ return rewriteValueARM_OpLess32U_0(v)
case OpLess64F:
- return rewriteValueARM_OpLess64F(v)
+ return rewriteValueARM_OpLess64F_0(v)
case OpLess8:
- return rewriteValueARM_OpLess8(v)
+ return rewriteValueARM_OpLess8_0(v)
case OpLess8U:
- return rewriteValueARM_OpLess8U(v)
+ return rewriteValueARM_OpLess8U_0(v)
case OpLoad:
- return rewriteValueARM_OpLoad(v)
+ return rewriteValueARM_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueARM_OpLsh16x16(v)
+ return rewriteValueARM_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueARM_OpLsh16x32(v)
+ return rewriteValueARM_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueARM_OpLsh16x64(v)
+ return rewriteValueARM_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueARM_OpLsh16x8(v)
+ return rewriteValueARM_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueARM_OpLsh32x16(v)
+ return rewriteValueARM_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueARM_OpLsh32x32(v)
+ return rewriteValueARM_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueARM_OpLsh32x64(v)
+ return rewriteValueARM_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueARM_OpLsh32x8(v)
+ return rewriteValueARM_OpLsh32x8_0(v)
case OpLsh8x16:
- return rewriteValueARM_OpLsh8x16(v)
+ return rewriteValueARM_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueARM_OpLsh8x32(v)
+ return rewriteValueARM_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueARM_OpLsh8x64(v)
+ return rewriteValueARM_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueARM_OpLsh8x8(v)
+ return rewriteValueARM_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueARM_OpMod16(v)
+ return rewriteValueARM_OpMod16_0(v)
case OpMod16u:
- return rewriteValueARM_OpMod16u(v)
+ return rewriteValueARM_OpMod16u_0(v)
case OpMod32:
- return rewriteValueARM_OpMod32(v)
+ return rewriteValueARM_OpMod32_0(v)
case OpMod32u:
- return rewriteValueARM_OpMod32u(v)
+ return rewriteValueARM_OpMod32u_0(v)
case OpMod8:
- return rewriteValueARM_OpMod8(v)
+ return rewriteValueARM_OpMod8_0(v)
case OpMod8u:
- return rewriteValueARM_OpMod8u(v)
+ return rewriteValueARM_OpMod8u_0(v)
case OpMove:
- return rewriteValueARM_OpMove(v)
+ return rewriteValueARM_OpMove_0(v)
case OpMul16:
- return rewriteValueARM_OpMul16(v)
+ return rewriteValueARM_OpMul16_0(v)
case OpMul32:
- return rewriteValueARM_OpMul32(v)
+ return rewriteValueARM_OpMul32_0(v)
case OpMul32F:
- return rewriteValueARM_OpMul32F(v)
+ return rewriteValueARM_OpMul32F_0(v)
case OpMul32uhilo:
- return rewriteValueARM_OpMul32uhilo(v)
+ return rewriteValueARM_OpMul32uhilo_0(v)
case OpMul64F:
- return rewriteValueARM_OpMul64F(v)
+ return rewriteValueARM_OpMul64F_0(v)
case OpMul8:
- return rewriteValueARM_OpMul8(v)
+ return rewriteValueARM_OpMul8_0(v)
case OpNeg16:
- return rewriteValueARM_OpNeg16(v)
+ return rewriteValueARM_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueARM_OpNeg32(v)
+ return rewriteValueARM_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueARM_OpNeg32F(v)
+ return rewriteValueARM_OpNeg32F_0(v)
case OpNeg64F:
- return rewriteValueARM_OpNeg64F(v)
+ return rewriteValueARM_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueARM_OpNeg8(v)
+ return rewriteValueARM_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueARM_OpNeq16(v)
+ return rewriteValueARM_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueARM_OpNeq32(v)
+ return rewriteValueARM_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueARM_OpNeq32F(v)
+ return rewriteValueARM_OpNeq32F_0(v)
case OpNeq64F:
- return rewriteValueARM_OpNeq64F(v)
+ return rewriteValueARM_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueARM_OpNeq8(v)
+ return rewriteValueARM_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueARM_OpNeqB(v)
+ return rewriteValueARM_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueARM_OpNeqPtr(v)
+ return rewriteValueARM_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueARM_OpNilCheck(v)
+ return rewriteValueARM_OpNilCheck_0(v)
case OpNot:
- return rewriteValueARM_OpNot(v)
+ return rewriteValueARM_OpNot_0(v)
case OpOffPtr:
- return rewriteValueARM_OpOffPtr(v)
+ return rewriteValueARM_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueARM_OpOr16(v)
+ return rewriteValueARM_OpOr16_0(v)
case OpOr32:
- return rewriteValueARM_OpOr32(v)
+ return rewriteValueARM_OpOr32_0(v)
case OpOr8:
- return rewriteValueARM_OpOr8(v)
+ return rewriteValueARM_OpOr8_0(v)
case OpOrB:
- return rewriteValueARM_OpOrB(v)
+ return rewriteValueARM_OpOrB_0(v)
case OpRound32F:
- return rewriteValueARM_OpRound32F(v)
+ return rewriteValueARM_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueARM_OpRound64F(v)
+ return rewriteValueARM_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueARM_OpRsh16Ux16(v)
+ return rewriteValueARM_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueARM_OpRsh16Ux32(v)
+ return rewriteValueARM_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueARM_OpRsh16Ux64(v)
+ return rewriteValueARM_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueARM_OpRsh16Ux8(v)
+ return rewriteValueARM_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueARM_OpRsh16x16(v)
+ return rewriteValueARM_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueARM_OpRsh16x32(v)
+ return rewriteValueARM_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueARM_OpRsh16x64(v)
+ return rewriteValueARM_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueARM_OpRsh16x8(v)
+ return rewriteValueARM_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueARM_OpRsh32Ux16(v)
+ return rewriteValueARM_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueARM_OpRsh32Ux32(v)
+ return rewriteValueARM_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueARM_OpRsh32Ux64(v)
+ return rewriteValueARM_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueARM_OpRsh32Ux8(v)
+ return rewriteValueARM_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueARM_OpRsh32x16(v)
+ return rewriteValueARM_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueARM_OpRsh32x32(v)
+ return rewriteValueARM_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueARM_OpRsh32x64(v)
+ return rewriteValueARM_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueARM_OpRsh32x8(v)
+ return rewriteValueARM_OpRsh32x8_0(v)
case OpRsh8Ux16:
- return rewriteValueARM_OpRsh8Ux16(v)
+ return rewriteValueARM_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueARM_OpRsh8Ux32(v)
+ return rewriteValueARM_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueARM_OpRsh8Ux64(v)
+ return rewriteValueARM_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueARM_OpRsh8Ux8(v)
+ return rewriteValueARM_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueARM_OpRsh8x16(v)
+ return rewriteValueARM_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueARM_OpRsh8x32(v)
+ return rewriteValueARM_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueARM_OpRsh8x64(v)
+ return rewriteValueARM_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueARM_OpRsh8x8(v)
+ return rewriteValueARM_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueARM_OpSelect0(v)
+ return rewriteValueARM_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueARM_OpSelect1(v)
+ return rewriteValueARM_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueARM_OpSignExt16to32(v)
+ return rewriteValueARM_OpSignExt16to32_0(v)
case OpSignExt8to16:
- return rewriteValueARM_OpSignExt8to16(v)
+ return rewriteValueARM_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueARM_OpSignExt8to32(v)
+ return rewriteValueARM_OpSignExt8to32_0(v)
case OpSignmask:
- return rewriteValueARM_OpSignmask(v)
+ return rewriteValueARM_OpSignmask_0(v)
case OpSlicemask:
- return rewriteValueARM_OpSlicemask(v)
+ return rewriteValueARM_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueARM_OpSqrt(v)
+ return rewriteValueARM_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueARM_OpStaticCall(v)
+ return rewriteValueARM_OpStaticCall_0(v)
case OpStore:
- return rewriteValueARM_OpStore(v)
+ return rewriteValueARM_OpStore_0(v)
case OpSub16:
- return rewriteValueARM_OpSub16(v)
+ return rewriteValueARM_OpSub16_0(v)
case OpSub32:
- return rewriteValueARM_OpSub32(v)
+ return rewriteValueARM_OpSub32_0(v)
case OpSub32F:
- return rewriteValueARM_OpSub32F(v)
+ return rewriteValueARM_OpSub32F_0(v)
case OpSub32carry:
- return rewriteValueARM_OpSub32carry(v)
+ return rewriteValueARM_OpSub32carry_0(v)
case OpSub32withcarry:
- return rewriteValueARM_OpSub32withcarry(v)
+ return rewriteValueARM_OpSub32withcarry_0(v)
case OpSub64F:
- return rewriteValueARM_OpSub64F(v)
+ return rewriteValueARM_OpSub64F_0(v)
case OpSub8:
- return rewriteValueARM_OpSub8(v)
+ return rewriteValueARM_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueARM_OpSubPtr(v)
+ return rewriteValueARM_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueARM_OpTrunc16to8(v)
+ return rewriteValueARM_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueARM_OpTrunc32to16(v)
+ return rewriteValueARM_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueARM_OpTrunc32to8(v)
+ return rewriteValueARM_OpTrunc32to8_0(v)
case OpXor16:
- return rewriteValueARM_OpXor16(v)
+ return rewriteValueARM_OpXor16_0(v)
case OpXor32:
- return rewriteValueARM_OpXor32(v)
+ return rewriteValueARM_OpXor32_0(v)
case OpXor8:
- return rewriteValueARM_OpXor8(v)
+ return rewriteValueARM_OpXor8_0(v)
case OpZero:
- return rewriteValueARM_OpZero(v)
+ return rewriteValueARM_OpZero_0(v)
case OpZeroExt16to32:
- return rewriteValueARM_OpZeroExt16to32(v)
+ return rewriteValueARM_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
- return rewriteValueARM_OpZeroExt8to16(v)
+ return rewriteValueARM_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueARM_OpZeroExt8to32(v)
+ return rewriteValueARM_OpZeroExt8to32_0(v)
case OpZeromask:
- return rewriteValueARM_OpZeromask(v)
+ return rewriteValueARM_OpZeromask_0(v)
}
return false
}
-func rewriteValueARM_OpARMADC(v *Value) bool {
+func rewriteValueARM_OpARMADC_0(v *Value) bool {
// match: (ADC (MOVWconst [c]) x flags)
// cond:
// result: (ADCconst [c] x flags)
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADC_10(v *Value) bool {
// match: (ADC (SRLconst [c] y) x flags)
// cond:
// result: (ADCshiftRL x y [c] flags)
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADC_20(v *Value) bool {
// match: (ADC x (SRL y z) flags)
// cond:
// result: (ADCshiftRLreg x y z flags)
}
return false
}
-func rewriteValueARM_OpARMADCconst(v *Value) bool {
+func rewriteValueARM_OpARMADCconst_0(v *Value) bool {
// match: (ADCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (ADCconst [int64(int32(c+d))] x flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftLL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftLLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRA (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRAreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADCshiftRLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMADD(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM_OpARMADD_0(v *Value) bool {
// match: (ADD x (MOVWconst [c]))
// cond:
// result: (ADDconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADD_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ADD x (SRL y z))
// cond:
// result: (ADDshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMADDS(v *Value) bool {
+func rewriteValueARM_OpARMADDS_0(v *Value) bool {
// match: (ADDS x (MOVWconst [c]))
// cond:
// result: (ADDSconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMADDS_10(v *Value) bool {
// match: (ADDS x (SRL y z))
// cond:
// result: (ADDSshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDSshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMADDconst(v *Value) bool {
+func rewriteValueARM_OpARMADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// cond:
// result: (MOVWaddr [off1+off2] {sym} ptr)
}
return false
}
-func rewriteValueARM_OpARMADDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMADDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMADDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMAND(v *Value) bool {
+func rewriteValueARM_OpARMAND_0(v *Value) bool {
// match: (AND x (MOVWconst [c]))
// cond:
// result: (ANDconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMAND_10(v *Value) bool {
// match: (AND x (SRL y z))
// cond:
// result: (ANDshiftRLreg x y z)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMAND_20(v *Value) bool {
// match: (AND (MVNshiftRL y [c]) x)
// cond:
// result: (BICshiftRL x y [c])
}
return false
}
-func rewriteValueARM_OpARMANDconst(v *Value) bool {
+func rewriteValueARM_OpARMANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMANDshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMANDshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMANDshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMBIC(v *Value) bool {
+func rewriteValueARM_OpARMBIC_0(v *Value) bool {
// match: (BIC x (MOVWconst [c]))
// cond:
// result: (BICconst [c] x)
}
return false
}
-func rewriteValueARM_OpARMBICconst(v *Value) bool {
+func rewriteValueARM_OpARMBICconst_0(v *Value) bool {
// match: (BICconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM_OpARMBICshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLL_0(v *Value) bool {
// match: (BICshiftLL x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint32(c)<<uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMBICshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftLLreg_0(v *Value) bool {
// match: (BICshiftLLreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftLL x y [c])
}
return false
}
-func rewriteValueARM_OpARMBICshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRA_0(v *Value) bool {
// match: (BICshiftRA x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(int32(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool {
// match: (BICshiftRAreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftRA x y [c])
}
return false
}
-func rewriteValueARM_OpARMBICshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool {
// match: (BICshiftRL x (MOVWconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint32(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool {
// match: (BICshiftRLreg x y (MOVWconst [c]))
// cond:
// result: (BICshiftRL x y [c])
}
return false
}
-func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool {
// match: (CMOVWHSconst _ (FlagEQ) [c])
// cond:
// result: (MOVWconst [c])
}
return false
}
-func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool {
+func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool {
// match: (CMOVWLSconst _ (FlagEQ) [c])
// cond:
// result: (MOVWconst [c])
}
return false
}
-func rewriteValueARM_OpARMCMP(v *Value) bool {
+func rewriteValueARM_OpARMCMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVWconst [c]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMCMP_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (CMP x (SRL y z))
// cond:
// result: (CMPshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMCMPD(v *Value) bool {
+func rewriteValueARM_OpARMCMPD_0(v *Value) bool {
// match: (CMPD x (MOVDconst [0]))
// cond:
// result: (CMPD0 x)
}
return false
}
-func rewriteValueARM_OpARMCMPF(v *Value) bool {
+func rewriteValueARM_OpARMCMPF_0(v *Value) bool {
// match: (CMPF x (MOVFconst [0]))
// cond:
// result: (CMPF0 x)
}
return false
}
-func rewriteValueARM_OpARMCMPconst(v *Value) bool {
+func rewriteValueARM_OpARMCMPconst_0(v *Value) bool {
// match: (CMPconst (MOVWconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMEqual(v *Value) bool {
+func rewriteValueARM_OpARMEqual_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueARM_OpARMGreaterEqual(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool {
// match: (GreaterEqualU (FlagEQ))
// cond:
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueARM_OpARMGreaterThan(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMGreaterThanU(v *Value) bool {
+func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool {
// match: (GreaterThanU (FlagEQ))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMLessEqual(v *Value) bool {
+func rewriteValueARM_OpARMLessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueARM_OpARMLessEqualU(v *Value) bool {
+func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool {
// match: (LessEqualU (FlagEQ))
// cond:
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueARM_OpARMLessThan(v *Value) bool {
+func rewriteValueARM_OpARMLessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMLessThanU(v *Value) bool {
+func rewriteValueARM_OpARMLessThanU_0(v *Value) bool {
// match: (LessThanU (FlagEQ))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMMOVBUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVBUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVBUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVWreg x)
}
return false
}
-func rewriteValueARM_OpARMMOVBload(v *Value) bool {
+func rewriteValueARM_OpARMMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVBload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVBreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVWreg x)
}
return false
}
-func rewriteValueARM_OpARMMOVBstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVDload(v *Value) bool {
+func rewriteValueARM_OpARMMOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVDstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVFload(v *Value) bool {
+func rewriteValueARM_OpARMMOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVFload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVFstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVHUload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVHUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVHUreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVWreg x)
}
return false
}
-func rewriteValueARM_OpARMMOVHload(v *Value) bool {
+func rewriteValueARM_OpARMMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond:
// result: (MOVHload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM_OpARMMOVHreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVWreg x)
}
return false
}
-func rewriteValueARM_OpARMMOVHstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond:
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVWload(v *Value) bool {
+func rewriteValueARM_OpARMMOVWload_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool {
// match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _))
// cond: isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool {
// match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool {
// match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool {
// match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _))
// cond: c==d && isSamePtr(ptr, ptr2)
// result: x
}
return false
}
-func rewriteValueARM_OpARMMOVWreg(v *Value) bool {
+func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool {
// match: (MOVWreg x)
// cond: x.Uses == 1
// result: (MOVWnop x)
}
return false
}
-func rewriteValueARM_OpARMMOVWstore(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool {
// match: (MOVWstoreidx ptr (MOVWconst [c]) val mem)
// cond:
// result: (MOVWstore [c] ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftLL_0(v *Value) bool {
// match: (MOVWstoreshiftLL ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(uint32(c)<<uint64(d))] ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRA_0(v *Value) bool {
// match: (MOVWstoreshiftRA ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(int32(c)>>uint64(d))] ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool {
// match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem)
// cond:
// result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem)
}
return false
}
-func rewriteValueARM_OpARMMUL(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM_OpARMMUL_0(v *Value) bool {
// match: (MUL x (MOVWconst [c]))
// cond: int32(c) == -1
// result: (RSBconst [0] x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMUL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MUL x (MOVWconst [c]))
// cond: isPowerOfTwo(c+1) && int32(c) >= 7
// result: (RSBshiftLL x x [log2(c+1)])
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMUL_20(v *Value) bool {
// match: (MUL (MOVWconst [c]) (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(c*d))])
}
return false
}
-func rewriteValueARM_OpARMMULA(v *Value) bool {
+func rewriteValueARM_OpARMMULA_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULA x (MOVWconst [c]) a)
v.AddArg(a)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMULA_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULA (MOVWconst [c]) x a)
// cond: int32(c) == -1
// result: (SUB a x)
v.AddArg(a)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMMULA_20(v *Value) bool {
// match: (MULA (MOVWconst [c]) (MOVWconst [d]) a)
// cond:
// result: (ADDconst [int64(int32(c*d))] a)
}
return false
}
-func rewriteValueARM_OpARMMVN(v *Value) bool {
+func rewriteValueARM_OpARMMVN_0(v *Value) bool {
// match: (MVN (MOVWconst [c]))
// cond:
// result: (MOVWconst [^c])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLL_0(v *Value) bool {
// match: (MVNshiftLL (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(uint32(c)<<uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftLLreg_0(v *Value) bool {
// match: (MVNshiftLLreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftLL x [c])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRA_0(v *Value) bool {
// match: (MVNshiftRA (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(int32(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool {
// match: (MVNshiftRAreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftRA x [c])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool {
// match: (MVNshiftRL (MOVWconst [c]) [d])
// cond:
// result: (MOVWconst [^int64(uint32(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool {
// match: (MVNshiftRLreg x (MOVWconst [c]))
// cond:
// result: (MVNshiftRL x [c])
}
return false
}
-func rewriteValueARM_OpARMNotEqual(v *Value) bool {
+func rewriteValueARM_OpARMNotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpARMOR(v *Value) bool {
+func rewriteValueARM_OpARMOR_0(v *Value) bool {
// match: (OR x (MOVWconst [c]))
// cond:
// result: (ORconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMOR_10(v *Value) bool {
// match: (OR x (SRL y z))
// cond:
// result: (ORshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMORconst(v *Value) bool {
+func rewriteValueARM_OpARMORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM_OpARMORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSB(v *Value) bool {
+func rewriteValueARM_OpARMRSB_0(v *Value) bool {
// match: (RSB (MOVWconst [c]) x)
// cond:
// result: (SUBconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMRSB_10(v *Value) bool {
// match: (RSB x (SRL y z))
// cond:
// result: (RSBshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBSshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSBconst(v *Value) bool {
+func rewriteValueARM_OpARMRSBconst_0(v *Value) bool {
// match: (RSBconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(c-d))])
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSBshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMRSCconst(v *Value) bool {
+func rewriteValueARM_OpARMRSCconst_0(v *Value) bool {
// match: (RSCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (RSCconst [int64(int32(c-d))] x flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftLL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftLLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRA (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRAreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (RSCshiftRLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMSBC(v *Value) bool {
+func rewriteValueARM_OpARMSBC_0(v *Value) bool {
// match: (SBC (MOVWconst [c]) x flags)
// cond:
// result: (RSCconst [c] x flags)
v.AddArg(flags)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSBC_10(v *Value) bool {
// match: (SBC x (SRL y z) flags)
// cond:
// result: (SBCshiftRLreg x y z flags)
}
return false
}
-func rewriteValueARM_OpARMSBCconst(v *Value) bool {
+func rewriteValueARM_OpARMSBCconst_0(v *Value) bool {
// match: (SBCconst [c] (ADDconst [d] x) flags)
// cond:
// result: (SBCconst [int64(int32(c-d))] x flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftLL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftLLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRA (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRAreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRL (MOVWconst [c]) x [d] flags)
}
return false
}
-func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SBCshiftRLreg (MOVWconst [c]) x y flags)
}
return false
}
-func rewriteValueARM_OpARMSLL(v *Value) bool {
+func rewriteValueARM_OpARMSLL_0(v *Value) bool {
// match: (SLL x (MOVWconst [c]))
// cond:
// result: (SLLconst x [c&31])
}
return false
}
-func rewriteValueARM_OpARMSLLconst(v *Value) bool {
+func rewriteValueARM_OpARMSLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)<<uint64(c))])
}
return false
}
-func rewriteValueARM_OpARMSRA(v *Value) bool {
+func rewriteValueARM_OpARMSRA_0(v *Value) bool {
// match: (SRA x (MOVWconst [c]))
// cond:
// result: (SRAconst x [c&31])
}
return false
}
-func rewriteValueARM_OpARMSRAcond(v *Value) bool {
+func rewriteValueARM_OpARMSRAcond_0(v *Value) bool {
// match: (SRAcond x _ (FlagEQ))
// cond:
// result: (SRAconst x [31])
}
return false
}
-func rewriteValueARM_OpARMSRAconst(v *Value) bool {
+func rewriteValueARM_OpARMSRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(d)>>uint64(c))])
}
return false
}
-func rewriteValueARM_OpARMSRL(v *Value) bool {
+func rewriteValueARM_OpARMSRL_0(v *Value) bool {
// match: (SRL x (MOVWconst [c]))
// cond:
// result: (SRLconst x [c&31])
}
return false
}
-func rewriteValueARM_OpARMSRLconst(v *Value) bool {
+func rewriteValueARM_OpARMSRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)>>uint64(c))])
}
return false
}
-func rewriteValueARM_OpARMSUB(v *Value) bool {
+func rewriteValueARM_OpARMSUB_0(v *Value) bool {
// match: (SUB (MOVWconst [c]) x)
// cond:
// result: (RSBconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSUB_10(v *Value) bool {
// match: (SUB x (SRL y z))
// cond:
// result: (SUBshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMSUBS(v *Value) bool {
+func rewriteValueARM_OpARMSUBS_0(v *Value) bool {
// match: (SUBS x (MOVWconst [c]))
// cond:
// result: (SUBSconst [c] x)
v.AddArg(z)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMSUBS_10(v *Value) bool {
// match: (SUBS (SRL y z) x)
// cond:
// result: (RSBSshiftRLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBSshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMSUBconst(v *Value) bool {
+func rewriteValueARM_OpARMSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMXOR(v *Value) bool {
+func rewriteValueARM_OpARMXOR_0(v *Value) bool {
// match: (XOR x (MOVWconst [c]))
// cond:
// result: (XORconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM_OpARMXOR_10(v *Value) bool {
// match: (XOR x (SLL y z))
// cond:
// result: (XORshiftLLreg x y z)
}
return false
}
-func rewriteValueARM_OpARMXORconst(v *Value) bool {
+func rewriteValueARM_OpARMXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM_OpARMXORshiftLL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMXORshiftRA(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRA (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRAreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMXORshiftRL(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRL (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRLreg (MOVWconst [c]) x y)
}
return false
}
-func rewriteValueARM_OpARMXORshiftRR(v *Value) bool {
+func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRR (MOVWconst [c]) x [d])
}
return false
}
-func rewriteValueARM_OpAdd16(v *Value) bool {
+func rewriteValueARM_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM_OpAdd32(v *Value) bool {
+func rewriteValueARM_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM_OpAdd32F(v *Value) bool {
+func rewriteValueARM_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
return true
}
}
-func rewriteValueARM_OpAdd32carry(v *Value) bool {
+func rewriteValueARM_OpAdd32carry_0(v *Value) bool {
// match: (Add32carry x y)
// cond:
// result: (ADDS x y)
return true
}
}
-func rewriteValueARM_OpAdd32withcarry(v *Value) bool {
+func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool {
// match: (Add32withcarry x y c)
// cond:
// result: (ADC x y c)
return true
}
}
-func rewriteValueARM_OpAdd64F(v *Value) bool {
+func rewriteValueARM_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
return true
}
}
-func rewriteValueARM_OpAdd8(v *Value) bool {
+func rewriteValueARM_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM_OpAddPtr(v *Value) bool {
+func rewriteValueARM_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM_OpAddr(v *Value) bool {
+func rewriteValueARM_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVWaddr {sym} base)
return true
}
}
-func rewriteValueARM_OpAnd16(v *Value) bool {
+func rewriteValueARM_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM_OpAnd32(v *Value) bool {
+func rewriteValueARM_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM_OpAnd8(v *Value) bool {
+func rewriteValueARM_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM_OpAndB(v *Value) bool {
+func rewriteValueARM_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM_OpAvg32u(v *Value) bool {
+func rewriteValueARM_OpAvg32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg32u <t> x y)
return true
}
}
-func rewriteValueARM_OpBitLen32(v *Value) bool {
+func rewriteValueARM_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
// match: (BitLen32 <t> x)
return true
}
}
-func rewriteValueARM_OpBswap32(v *Value) bool {
+func rewriteValueARM_OpBswap32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Bswap32 <t> x)
}
return false
}
-func rewriteValueARM_OpClosureCall(v *Value) bool {
+func rewriteValueARM_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueARM_OpCom16(v *Value) bool {
+func rewriteValueARM_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM_OpCom32(v *Value) bool {
+func rewriteValueARM_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM_OpCom8(v *Value) bool {
+func rewriteValueARM_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM_OpConst16(v *Value) bool {
+func rewriteValueARM_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueARM_OpConst32(v *Value) bool {
+func rewriteValueARM_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueARM_OpConst32F(v *Value) bool {
+func rewriteValueARM_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
return true
}
}
-func rewriteValueARM_OpConst64F(v *Value) bool {
+func rewriteValueARM_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueARM_OpConst8(v *Value) bool {
+func rewriteValueARM_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueARM_OpConstBool(v *Value) bool {
+func rewriteValueARM_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVWconst [b])
return true
}
}
-func rewriteValueARM_OpConstNil(v *Value) bool {
+func rewriteValueARM_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVWconst [0])
return true
}
}
-func rewriteValueARM_OpConvert(v *Value) bool {
+func rewriteValueARM_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVWconvert x mem)
return true
}
}
-func rewriteValueARM_OpCtz32(v *Value) bool {
+func rewriteValueARM_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz32 <t> x)
}
return false
}
-func rewriteValueARM_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (MOVFW x)
return true
}
}
-func rewriteValueARM_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool {
// match: (Cvt32Fto32U x)
// cond:
// result: (MOVFWU x)
return true
}
}
-func rewriteValueARM_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
return true
}
}
-func rewriteValueARM_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool {
// match: (Cvt32Uto32F x)
// cond:
// result: (MOVWUF x)
return true
}
}
-func rewriteValueARM_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool {
// match: (Cvt32Uto64F x)
// cond:
// result: (MOVWUD x)
return true
}
}
-func rewriteValueARM_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
return true
}
}
-func rewriteValueARM_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
return true
}
}
-func rewriteValueARM_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (MOVDW x)
return true
}
}
-func rewriteValueARM_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
return true
}
}
-func rewriteValueARM_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool {
// match: (Cvt64Fto32U x)
// cond:
// result: (MOVDWU x)
return true
}
}
-func rewriteValueARM_OpDiv16(v *Value) bool {
+func rewriteValueARM_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpDiv16u(v *Value) bool {
+func rewriteValueARM_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpDiv32(v *Value) bool {
+func rewriteValueARM_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpDiv32F(v *Value) bool {
+func rewriteValueARM_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
return true
}
}
-func rewriteValueARM_OpDiv32u(v *Value) bool {
+func rewriteValueARM_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpDiv64F(v *Value) bool {
+func rewriteValueARM_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
return true
}
}
-func rewriteValueARM_OpDiv8(v *Value) bool {
+func rewriteValueARM_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpDiv8u(v *Value) bool {
+func rewriteValueARM_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpEq16(v *Value) bool {
+func rewriteValueARM_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpEq32(v *Value) bool {
+func rewriteValueARM_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
return true
}
}
-func rewriteValueARM_OpEq32F(v *Value) bool {
+func rewriteValueARM_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValueARM_OpEq64F(v *Value) bool {
+func rewriteValueARM_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValueARM_OpEq8(v *Value) bool {
+func rewriteValueARM_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpEqB(v *Value) bool {
+func rewriteValueARM_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpEqPtr(v *Value) bool {
+func rewriteValueARM_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
return true
}
}
-func rewriteValueARM_OpGeq16(v *Value) bool {
+func rewriteValueARM_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGeq16U(v *Value) bool {
+func rewriteValueARM_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGeq32(v *Value) bool {
+func rewriteValueARM_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
return true
}
}
-func rewriteValueARM_OpGeq32F(v *Value) bool {
+func rewriteValueARM_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValueARM_OpGeq32U(v *Value) bool {
+func rewriteValueARM_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
return true
}
}
-func rewriteValueARM_OpGeq64F(v *Value) bool {
+func rewriteValueARM_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValueARM_OpGeq8(v *Value) bool {
+func rewriteValueARM_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGeq8U(v *Value) bool {
+func rewriteValueARM_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueARM_OpGreater16(v *Value) bool {
+func rewriteValueARM_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGreater16U(v *Value) bool {
+func rewriteValueARM_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGreater32(v *Value) bool {
+func rewriteValueARM_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
return true
}
}
-func rewriteValueARM_OpGreater32F(v *Value) bool {
+func rewriteValueARM_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValueARM_OpGreater32U(v *Value) bool {
+func rewriteValueARM_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
return true
}
}
-func rewriteValueARM_OpGreater64F(v *Value) bool {
+func rewriteValueARM_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValueARM_OpGreater8(v *Value) bool {
+func rewriteValueARM_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpGreater8U(v *Value) bool {
+func rewriteValueARM_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpHmul32(v *Value) bool {
+func rewriteValueARM_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (HMUL x y)
return true
}
}
-func rewriteValueARM_OpHmul32u(v *Value) bool {
+func rewriteValueARM_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (HMULU x y)
return true
}
}
-func rewriteValueARM_OpInterCall(v *Value) bool {
+func rewriteValueARM_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueARM_OpIsInBounds(v *Value) bool {
+func rewriteValueARM_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
return true
}
}
-func rewriteValueARM_OpIsNonNil(v *Value) bool {
+func rewriteValueARM_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
return true
}
}
-func rewriteValueARM_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
return true
}
}
-func rewriteValueARM_OpLeq16(v *Value) bool {
+func rewriteValueARM_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLeq16U(v *Value) bool {
+func rewriteValueARM_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLeq32(v *Value) bool {
+func rewriteValueARM_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
return true
}
}
-func rewriteValueARM_OpLeq32F(v *Value) bool {
+func rewriteValueARM_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValueARM_OpLeq32U(v *Value) bool {
+func rewriteValueARM_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
return true
}
}
-func rewriteValueARM_OpLeq64F(v *Value) bool {
+func rewriteValueARM_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValueARM_OpLeq8(v *Value) bool {
+func rewriteValueARM_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLeq8U(v *Value) bool {
+func rewriteValueARM_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLess16(v *Value) bool {
+func rewriteValueARM_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLess16U(v *Value) bool {
+func rewriteValueARM_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLess32(v *Value) bool {
+func rewriteValueARM_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
return true
}
}
-func rewriteValueARM_OpLess32F(v *Value) bool {
+func rewriteValueARM_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValueARM_OpLess32U(v *Value) bool {
+func rewriteValueARM_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
return true
}
}
-func rewriteValueARM_OpLess64F(v *Value) bool {
+func rewriteValueARM_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValueARM_OpLess8(v *Value) bool {
+func rewriteValueARM_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLess8U(v *Value) bool {
+func rewriteValueARM_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLoad(v *Value) bool {
+func rewriteValueARM_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
}
return false
}
-func rewriteValueARM_OpLsh16x16(v *Value) bool {
+func rewriteValueARM_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLsh16x32(v *Value) bool {
+func rewriteValueARM_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 x y)
return true
}
}
-func rewriteValueARM_OpLsh16x64(v *Value) bool {
+func rewriteValueARM_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint64(c) < 16
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueARM_OpLsh16x8(v *Value) bool {
+func rewriteValueARM_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLsh32x16(v *Value) bool {
+func rewriteValueARM_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLsh32x32(v *Value) bool {
+func rewriteValueARM_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 x y)
return true
}
}
-func rewriteValueARM_OpLsh32x64(v *Value) bool {
+func rewriteValueARM_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueARM_OpLsh32x8(v *Value) bool {
+func rewriteValueARM_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLsh8x16(v *Value) bool {
+func rewriteValueARM_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpLsh8x32(v *Value) bool {
+func rewriteValueARM_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 x y)
return true
}
}
-func rewriteValueARM_OpLsh8x64(v *Value) bool {
+func rewriteValueARM_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint64(c) < 8
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueARM_OpLsh8x8(v *Value) bool {
+func rewriteValueARM_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod16(v *Value) bool {
+func rewriteValueARM_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod16u(v *Value) bool {
+func rewriteValueARM_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod32(v *Value) bool {
+func rewriteValueARM_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod32u(v *Value) bool {
+func rewriteValueARM_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod8(v *Value) bool {
+func rewriteValueARM_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMod8u(v *Value) bool {
+func rewriteValueARM_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpMove(v *Value) bool {
+func rewriteValueARM_OpMove_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueARM_OpMul16(v *Value) bool {
+func rewriteValueARM_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueARM_OpMul32(v *Value) bool {
+func rewriteValueARM_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueARM_OpMul32F(v *Value) bool {
+func rewriteValueARM_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
return true
}
}
-func rewriteValueARM_OpMul32uhilo(v *Value) bool {
+func rewriteValueARM_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULLU x y)
return true
}
}
-func rewriteValueARM_OpMul64F(v *Value) bool {
+func rewriteValueARM_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
return true
}
}
-func rewriteValueARM_OpMul8(v *Value) bool {
+func rewriteValueARM_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueARM_OpNeg16(v *Value) bool {
+func rewriteValueARM_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (RSBconst [0] x)
return true
}
}
-func rewriteValueARM_OpNeg32(v *Value) bool {
+func rewriteValueARM_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (RSBconst [0] x)
return true
}
}
-func rewriteValueARM_OpNeg32F(v *Value) bool {
+func rewriteValueARM_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
return true
}
}
-func rewriteValueARM_OpNeg64F(v *Value) bool {
+func rewriteValueARM_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
return true
}
}
-func rewriteValueARM_OpNeg8(v *Value) bool {
+func rewriteValueARM_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (RSBconst [0] x)
return true
}
}
-func rewriteValueARM_OpNeq16(v *Value) bool {
+func rewriteValueARM_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpNeq32(v *Value) bool {
+func rewriteValueARM_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
return true
}
}
-func rewriteValueARM_OpNeq32F(v *Value) bool {
+func rewriteValueARM_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValueARM_OpNeq64F(v *Value) bool {
+func rewriteValueARM_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValueARM_OpNeq8(v *Value) bool {
+func rewriteValueARM_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpNeqB(v *Value) bool {
+func rewriteValueARM_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM_OpNeqPtr(v *Value) bool {
+func rewriteValueARM_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
return true
}
}
-func rewriteValueARM_OpNilCheck(v *Value) bool {
+func rewriteValueARM_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueARM_OpNot(v *Value) bool {
+func rewriteValueARM_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
return true
}
}
-func rewriteValueARM_OpOffPtr(v *Value) bool {
+func rewriteValueARM_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVWaddr [off] ptr)
return true
}
}
-func rewriteValueARM_OpOr16(v *Value) bool {
+func rewriteValueARM_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM_OpOr32(v *Value) bool {
+func rewriteValueARM_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM_OpOr8(v *Value) bool {
+func rewriteValueARM_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM_OpOrB(v *Value) bool {
+func rewriteValueARM_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM_OpRound32F(v *Value) bool {
+func rewriteValueARM_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM_OpRound64F(v *Value) bool {
+func rewriteValueARM_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueARM_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh16x16(v *Value) bool {
+func rewriteValueARM_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh16x32(v *Value) bool {
+func rewriteValueARM_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh16x64(v *Value) bool {
+func rewriteValueARM_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueARM_OpRsh16x8(v *Value) bool {
+func rewriteValueARM_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 x y)
return true
}
}
-func rewriteValueARM_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRLconst x [c])
}
return false
}
-func rewriteValueARM_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh32x16(v *Value) bool {
+func rewriteValueARM_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh32x32(v *Value) bool {
+func rewriteValueARM_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 x y)
return true
}
}
-func rewriteValueARM_OpRsh32x64(v *Value) bool {
+func rewriteValueARM_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint64(c) < 32
// result: (SRAconst x [c])
}
return false
}
-func rewriteValueARM_OpRsh32x8(v *Value) bool {
+func rewriteValueARM_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueARM_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8x16(v *Value) bool {
+func rewriteValueARM_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8x32(v *Value) bool {
+func rewriteValueARM_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpRsh8x64(v *Value) bool {
+func rewriteValueARM_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueARM_OpRsh8x8(v *Value) bool {
+func rewriteValueARM_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM_OpSelect0(v *Value) bool {
+func rewriteValueARM_OpSelect0_0(v *Value) bool {
// match: (Select0 (CALLudiv x (MOVWconst [1])))
// cond:
// result: x
}
return false
}
-func rewriteValueARM_OpSelect1(v *Value) bool {
+func rewriteValueARM_OpSelect1_0(v *Value) bool {
// match: (Select1 (CALLudiv _ (MOVWconst [1])))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueARM_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueARM_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueARM_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueARM_OpSignmask(v *Value) bool {
+func rewriteValueARM_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SRAconst x [31])
return true
}
}
-func rewriteValueARM_OpSlicemask(v *Value) bool {
+func rewriteValueARM_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueARM_OpSqrt(v *Value) bool {
+func rewriteValueARM_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTD x)
return true
}
}
-func rewriteValueARM_OpStaticCall(v *Value) bool {
+func rewriteValueARM_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueARM_OpStore(v *Value) bool {
+func rewriteValueARM_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
}
return false
}
-func rewriteValueARM_OpSub16(v *Value) bool {
+func rewriteValueARM_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM_OpSub32(v *Value) bool {
+func rewriteValueARM_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM_OpSub32F(v *Value) bool {
+func rewriteValueARM_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
return true
}
}
-func rewriteValueARM_OpSub32carry(v *Value) bool {
+func rewriteValueARM_OpSub32carry_0(v *Value) bool {
// match: (Sub32carry x y)
// cond:
// result: (SUBS x y)
return true
}
}
-func rewriteValueARM_OpSub32withcarry(v *Value) bool {
+func rewriteValueARM_OpSub32withcarry_0(v *Value) bool {
// match: (Sub32withcarry x y c)
// cond:
// result: (SBC x y c)
return true
}
}
-func rewriteValueARM_OpSub64F(v *Value) bool {
+func rewriteValueARM_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
return true
}
}
-func rewriteValueARM_OpSub8(v *Value) bool {
+func rewriteValueARM_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM_OpSubPtr(v *Value) bool {
+func rewriteValueARM_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM_OpXor16(v *Value) bool {
+func rewriteValueARM_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM_OpXor32(v *Value) bool {
+func rewriteValueARM_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM_OpXor8(v *Value) bool {
+func rewriteValueARM_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM_OpZero(v *Value) bool {
+func rewriteValueARM_OpZero_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueARM_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueARM_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueARM_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueARM_OpZeromask(v *Value) bool {
+func rewriteValueARM_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
func rewriteValueARM64(v *Value) bool {
switch v.Op {
case OpARM64ADD:
- return rewriteValueARM64_OpARM64ADD(v)
+ return rewriteValueARM64_OpARM64ADD_0(v)
case OpARM64ADDconst:
- return rewriteValueARM64_OpARM64ADDconst(v)
+ return rewriteValueARM64_OpARM64ADDconst_0(v)
case OpARM64ADDshiftLL:
- return rewriteValueARM64_OpARM64ADDshiftLL(v)
+ return rewriteValueARM64_OpARM64ADDshiftLL_0(v)
case OpARM64ADDshiftRA:
- return rewriteValueARM64_OpARM64ADDshiftRA(v)
+ return rewriteValueARM64_OpARM64ADDshiftRA_0(v)
case OpARM64ADDshiftRL:
- return rewriteValueARM64_OpARM64ADDshiftRL(v)
+ return rewriteValueARM64_OpARM64ADDshiftRL_0(v)
case OpARM64AND:
- return rewriteValueARM64_OpARM64AND(v)
+ return rewriteValueARM64_OpARM64AND_0(v) || rewriteValueARM64_OpARM64AND_10(v)
case OpARM64ANDconst:
- return rewriteValueARM64_OpARM64ANDconst(v)
+ return rewriteValueARM64_OpARM64ANDconst_0(v)
case OpARM64ANDshiftLL:
- return rewriteValueARM64_OpARM64ANDshiftLL(v)
+ return rewriteValueARM64_OpARM64ANDshiftLL_0(v)
case OpARM64ANDshiftRA:
- return rewriteValueARM64_OpARM64ANDshiftRA(v)
+ return rewriteValueARM64_OpARM64ANDshiftRA_0(v)
case OpARM64ANDshiftRL:
- return rewriteValueARM64_OpARM64ANDshiftRL(v)
+ return rewriteValueARM64_OpARM64ANDshiftRL_0(v)
case OpARM64BIC:
- return rewriteValueARM64_OpARM64BIC(v)
+ return rewriteValueARM64_OpARM64BIC_0(v)
case OpARM64BICconst:
- return rewriteValueARM64_OpARM64BICconst(v)
+ return rewriteValueARM64_OpARM64BICconst_0(v)
case OpARM64BICshiftLL:
- return rewriteValueARM64_OpARM64BICshiftLL(v)
+ return rewriteValueARM64_OpARM64BICshiftLL_0(v)
case OpARM64BICshiftRA:
- return rewriteValueARM64_OpARM64BICshiftRA(v)
+ return rewriteValueARM64_OpARM64BICshiftRA_0(v)
case OpARM64BICshiftRL:
- return rewriteValueARM64_OpARM64BICshiftRL(v)
+ return rewriteValueARM64_OpARM64BICshiftRL_0(v)
case OpARM64CMP:
- return rewriteValueARM64_OpARM64CMP(v)
+ return rewriteValueARM64_OpARM64CMP_0(v)
case OpARM64CMPW:
- return rewriteValueARM64_OpARM64CMPW(v)
+ return rewriteValueARM64_OpARM64CMPW_0(v)
case OpARM64CMPWconst:
- return rewriteValueARM64_OpARM64CMPWconst(v)
+ return rewriteValueARM64_OpARM64CMPWconst_0(v)
case OpARM64CMPconst:
- return rewriteValueARM64_OpARM64CMPconst(v)
+ return rewriteValueARM64_OpARM64CMPconst_0(v)
case OpARM64CMPshiftLL:
- return rewriteValueARM64_OpARM64CMPshiftLL(v)
+ return rewriteValueARM64_OpARM64CMPshiftLL_0(v)
case OpARM64CMPshiftRA:
- return rewriteValueARM64_OpARM64CMPshiftRA(v)
+ return rewriteValueARM64_OpARM64CMPshiftRA_0(v)
case OpARM64CMPshiftRL:
- return rewriteValueARM64_OpARM64CMPshiftRL(v)
+ return rewriteValueARM64_OpARM64CMPshiftRL_0(v)
case OpARM64CSELULT:
- return rewriteValueARM64_OpARM64CSELULT(v)
+ return rewriteValueARM64_OpARM64CSELULT_0(v)
case OpARM64CSELULT0:
- return rewriteValueARM64_OpARM64CSELULT0(v)
+ return rewriteValueARM64_OpARM64CSELULT0_0(v)
case OpARM64DIV:
- return rewriteValueARM64_OpARM64DIV(v)
+ return rewriteValueARM64_OpARM64DIV_0(v)
case OpARM64DIVW:
- return rewriteValueARM64_OpARM64DIVW(v)
+ return rewriteValueARM64_OpARM64DIVW_0(v)
case OpARM64Equal:
- return rewriteValueARM64_OpARM64Equal(v)
+ return rewriteValueARM64_OpARM64Equal_0(v)
case OpARM64FMOVDload:
- return rewriteValueARM64_OpARM64FMOVDload(v)
+ return rewriteValueARM64_OpARM64FMOVDload_0(v)
case OpARM64FMOVDstore:
- return rewriteValueARM64_OpARM64FMOVDstore(v)
+ return rewriteValueARM64_OpARM64FMOVDstore_0(v)
case OpARM64FMOVSload:
- return rewriteValueARM64_OpARM64FMOVSload(v)
+ return rewriteValueARM64_OpARM64FMOVSload_0(v)
case OpARM64FMOVSstore:
- return rewriteValueARM64_OpARM64FMOVSstore(v)
+ return rewriteValueARM64_OpARM64FMOVSstore_0(v)
case OpARM64GreaterEqual:
- return rewriteValueARM64_OpARM64GreaterEqual(v)
+ return rewriteValueARM64_OpARM64GreaterEqual_0(v)
case OpARM64GreaterEqualU:
- return rewriteValueARM64_OpARM64GreaterEqualU(v)
+ return rewriteValueARM64_OpARM64GreaterEqualU_0(v)
case OpARM64GreaterThan:
- return rewriteValueARM64_OpARM64GreaterThan(v)
+ return rewriteValueARM64_OpARM64GreaterThan_0(v)
case OpARM64GreaterThanU:
- return rewriteValueARM64_OpARM64GreaterThanU(v)
+ return rewriteValueARM64_OpARM64GreaterThanU_0(v)
case OpARM64LessEqual:
- return rewriteValueARM64_OpARM64LessEqual(v)
+ return rewriteValueARM64_OpARM64LessEqual_0(v)
case OpARM64LessEqualU:
- return rewriteValueARM64_OpARM64LessEqualU(v)
+ return rewriteValueARM64_OpARM64LessEqualU_0(v)
case OpARM64LessThan:
- return rewriteValueARM64_OpARM64LessThan(v)
+ return rewriteValueARM64_OpARM64LessThan_0(v)
case OpARM64LessThanU:
- return rewriteValueARM64_OpARM64LessThanU(v)
+ return rewriteValueARM64_OpARM64LessThanU_0(v)
case OpARM64MOD:
- return rewriteValueARM64_OpARM64MOD(v)
+ return rewriteValueARM64_OpARM64MOD_0(v)
case OpARM64MODW:
- return rewriteValueARM64_OpARM64MODW(v)
+ return rewriteValueARM64_OpARM64MODW_0(v)
case OpARM64MOVBUload:
- return rewriteValueARM64_OpARM64MOVBUload(v)
+ return rewriteValueARM64_OpARM64MOVBUload_0(v)
case OpARM64MOVBUreg:
- return rewriteValueARM64_OpARM64MOVBUreg(v)
+ return rewriteValueARM64_OpARM64MOVBUreg_0(v)
case OpARM64MOVBload:
- return rewriteValueARM64_OpARM64MOVBload(v)
+ return rewriteValueARM64_OpARM64MOVBload_0(v)
case OpARM64MOVBreg:
- return rewriteValueARM64_OpARM64MOVBreg(v)
+ return rewriteValueARM64_OpARM64MOVBreg_0(v)
case OpARM64MOVBstore:
- return rewriteValueARM64_OpARM64MOVBstore(v)
+ return rewriteValueARM64_OpARM64MOVBstore_0(v)
case OpARM64MOVBstorezero:
- return rewriteValueARM64_OpARM64MOVBstorezero(v)
+ return rewriteValueARM64_OpARM64MOVBstorezero_0(v)
case OpARM64MOVDload:
- return rewriteValueARM64_OpARM64MOVDload(v)
+ return rewriteValueARM64_OpARM64MOVDload_0(v)
case OpARM64MOVDreg:
- return rewriteValueARM64_OpARM64MOVDreg(v)
+ return rewriteValueARM64_OpARM64MOVDreg_0(v)
case OpARM64MOVDstore:
- return rewriteValueARM64_OpARM64MOVDstore(v)
+ return rewriteValueARM64_OpARM64MOVDstore_0(v)
case OpARM64MOVDstorezero:
- return rewriteValueARM64_OpARM64MOVDstorezero(v)
+ return rewriteValueARM64_OpARM64MOVDstorezero_0(v)
case OpARM64MOVHUload:
- return rewriteValueARM64_OpARM64MOVHUload(v)
+ return rewriteValueARM64_OpARM64MOVHUload_0(v)
case OpARM64MOVHUreg:
- return rewriteValueARM64_OpARM64MOVHUreg(v)
+ return rewriteValueARM64_OpARM64MOVHUreg_0(v)
case OpARM64MOVHload:
- return rewriteValueARM64_OpARM64MOVHload(v)
+ return rewriteValueARM64_OpARM64MOVHload_0(v)
case OpARM64MOVHreg:
- return rewriteValueARM64_OpARM64MOVHreg(v)
+ return rewriteValueARM64_OpARM64MOVHreg_0(v)
case OpARM64MOVHstore:
- return rewriteValueARM64_OpARM64MOVHstore(v)
+ return rewriteValueARM64_OpARM64MOVHstore_0(v)
case OpARM64MOVHstorezero:
- return rewriteValueARM64_OpARM64MOVHstorezero(v)
+ return rewriteValueARM64_OpARM64MOVHstorezero_0(v)
case OpARM64MOVWUload:
- return rewriteValueARM64_OpARM64MOVWUload(v)
+ return rewriteValueARM64_OpARM64MOVWUload_0(v)
case OpARM64MOVWUreg:
- return rewriteValueARM64_OpARM64MOVWUreg(v)
+ return rewriteValueARM64_OpARM64MOVWUreg_0(v)
case OpARM64MOVWload:
- return rewriteValueARM64_OpARM64MOVWload(v)
+ return rewriteValueARM64_OpARM64MOVWload_0(v)
case OpARM64MOVWreg:
- return rewriteValueARM64_OpARM64MOVWreg(v)
+ return rewriteValueARM64_OpARM64MOVWreg_0(v) || rewriteValueARM64_OpARM64MOVWreg_10(v)
case OpARM64MOVWstore:
- return rewriteValueARM64_OpARM64MOVWstore(v)
+ return rewriteValueARM64_OpARM64MOVWstore_0(v)
case OpARM64MOVWstorezero:
- return rewriteValueARM64_OpARM64MOVWstorezero(v)
+ return rewriteValueARM64_OpARM64MOVWstorezero_0(v)
case OpARM64MUL:
- return rewriteValueARM64_OpARM64MUL(v)
+ return rewriteValueARM64_OpARM64MUL_0(v) || rewriteValueARM64_OpARM64MUL_10(v) || rewriteValueARM64_OpARM64MUL_20(v)
case OpARM64MULW:
- return rewriteValueARM64_OpARM64MULW(v)
+ return rewriteValueARM64_OpARM64MULW_0(v) || rewriteValueARM64_OpARM64MULW_10(v) || rewriteValueARM64_OpARM64MULW_20(v)
case OpARM64MVN:
- return rewriteValueARM64_OpARM64MVN(v)
+ return rewriteValueARM64_OpARM64MVN_0(v)
case OpARM64NEG:
- return rewriteValueARM64_OpARM64NEG(v)
+ return rewriteValueARM64_OpARM64NEG_0(v)
case OpARM64NotEqual:
- return rewriteValueARM64_OpARM64NotEqual(v)
+ return rewriteValueARM64_OpARM64NotEqual_0(v)
case OpARM64OR:
- return rewriteValueARM64_OpARM64OR(v)
+ return rewriteValueARM64_OpARM64OR_0(v) || rewriteValueARM64_OpARM64OR_10(v)
case OpARM64ORconst:
- return rewriteValueARM64_OpARM64ORconst(v)
+ return rewriteValueARM64_OpARM64ORconst_0(v)
case OpARM64ORshiftLL:
- return rewriteValueARM64_OpARM64ORshiftLL(v)
+ return rewriteValueARM64_OpARM64ORshiftLL_0(v) || rewriteValueARM64_OpARM64ORshiftLL_10(v)
case OpARM64ORshiftRA:
- return rewriteValueARM64_OpARM64ORshiftRA(v)
+ return rewriteValueARM64_OpARM64ORshiftRA_0(v)
case OpARM64ORshiftRL:
- return rewriteValueARM64_OpARM64ORshiftRL(v)
+ return rewriteValueARM64_OpARM64ORshiftRL_0(v)
case OpARM64SLL:
- return rewriteValueARM64_OpARM64SLL(v)
+ return rewriteValueARM64_OpARM64SLL_0(v)
case OpARM64SLLconst:
- return rewriteValueARM64_OpARM64SLLconst(v)
+ return rewriteValueARM64_OpARM64SLLconst_0(v)
case OpARM64SRA:
- return rewriteValueARM64_OpARM64SRA(v)
+ return rewriteValueARM64_OpARM64SRA_0(v)
case OpARM64SRAconst:
- return rewriteValueARM64_OpARM64SRAconst(v)
+ return rewriteValueARM64_OpARM64SRAconst_0(v)
case OpARM64SRL:
- return rewriteValueARM64_OpARM64SRL(v)
+ return rewriteValueARM64_OpARM64SRL_0(v)
case OpARM64SRLconst:
- return rewriteValueARM64_OpARM64SRLconst(v)
+ return rewriteValueARM64_OpARM64SRLconst_0(v)
case OpARM64SUB:
- return rewriteValueARM64_OpARM64SUB(v)
+ return rewriteValueARM64_OpARM64SUB_0(v)
case OpARM64SUBconst:
- return rewriteValueARM64_OpARM64SUBconst(v)
+ return rewriteValueARM64_OpARM64SUBconst_0(v)
case OpARM64SUBshiftLL:
- return rewriteValueARM64_OpARM64SUBshiftLL(v)
+ return rewriteValueARM64_OpARM64SUBshiftLL_0(v)
case OpARM64SUBshiftRA:
- return rewriteValueARM64_OpARM64SUBshiftRA(v)
+ return rewriteValueARM64_OpARM64SUBshiftRA_0(v)
case OpARM64SUBshiftRL:
- return rewriteValueARM64_OpARM64SUBshiftRL(v)
+ return rewriteValueARM64_OpARM64SUBshiftRL_0(v)
case OpARM64UDIV:
- return rewriteValueARM64_OpARM64UDIV(v)
+ return rewriteValueARM64_OpARM64UDIV_0(v)
case OpARM64UDIVW:
- return rewriteValueARM64_OpARM64UDIVW(v)
+ return rewriteValueARM64_OpARM64UDIVW_0(v)
case OpARM64UMOD:
- return rewriteValueARM64_OpARM64UMOD(v)
+ return rewriteValueARM64_OpARM64UMOD_0(v)
case OpARM64UMODW:
- return rewriteValueARM64_OpARM64UMODW(v)
+ return rewriteValueARM64_OpARM64UMODW_0(v)
case OpARM64XOR:
- return rewriteValueARM64_OpARM64XOR(v)
+ return rewriteValueARM64_OpARM64XOR_0(v)
case OpARM64XORconst:
- return rewriteValueARM64_OpARM64XORconst(v)
+ return rewriteValueARM64_OpARM64XORconst_0(v)
case OpARM64XORshiftLL:
- return rewriteValueARM64_OpARM64XORshiftLL(v)
+ return rewriteValueARM64_OpARM64XORshiftLL_0(v)
case OpARM64XORshiftRA:
- return rewriteValueARM64_OpARM64XORshiftRA(v)
+ return rewriteValueARM64_OpARM64XORshiftRA_0(v)
case OpARM64XORshiftRL:
- return rewriteValueARM64_OpARM64XORshiftRL(v)
+ return rewriteValueARM64_OpARM64XORshiftRL_0(v)
case OpAdd16:
- return rewriteValueARM64_OpAdd16(v)
+ return rewriteValueARM64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueARM64_OpAdd32(v)
+ return rewriteValueARM64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueARM64_OpAdd32F(v)
+ return rewriteValueARM64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueARM64_OpAdd64(v)
+ return rewriteValueARM64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueARM64_OpAdd64F(v)
+ return rewriteValueARM64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueARM64_OpAdd8(v)
+ return rewriteValueARM64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueARM64_OpAddPtr(v)
+ return rewriteValueARM64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueARM64_OpAddr(v)
+ return rewriteValueARM64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueARM64_OpAnd16(v)
+ return rewriteValueARM64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueARM64_OpAnd32(v)
+ return rewriteValueARM64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueARM64_OpAnd64(v)
+ return rewriteValueARM64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueARM64_OpAnd8(v)
+ return rewriteValueARM64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueARM64_OpAndB(v)
+ return rewriteValueARM64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueARM64_OpAtomicAdd32(v)
+ return rewriteValueARM64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueARM64_OpAtomicAdd64(v)
+ return rewriteValueARM64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValueARM64_OpAtomicAnd8(v)
+ return rewriteValueARM64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueARM64_OpAtomicCompareAndSwap32(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueARM64_OpAtomicCompareAndSwap64(v)
+ return rewriteValueARM64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueARM64_OpAtomicExchange32(v)
+ return rewriteValueARM64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueARM64_OpAtomicExchange64(v)
+ return rewriteValueARM64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueARM64_OpAtomicLoad32(v)
+ return rewriteValueARM64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueARM64_OpAtomicLoad64(v)
+ return rewriteValueARM64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueARM64_OpAtomicLoadPtr(v)
+ return rewriteValueARM64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValueARM64_OpAtomicOr8(v)
+ return rewriteValueARM64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValueARM64_OpAtomicStore32(v)
+ return rewriteValueARM64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueARM64_OpAtomicStore64(v)
+ return rewriteValueARM64_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueARM64_OpAtomicStorePtrNoWB(v)
+ return rewriteValueARM64_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueARM64_OpAvg64u(v)
+ return rewriteValueARM64_OpAvg64u_0(v)
case OpBitLen64:
- return rewriteValueARM64_OpBitLen64(v)
+ return rewriteValueARM64_OpBitLen64_0(v)
case OpBitRev16:
- return rewriteValueARM64_OpBitRev16(v)
+ return rewriteValueARM64_OpBitRev16_0(v)
case OpBitRev32:
- return rewriteValueARM64_OpBitRev32(v)
+ return rewriteValueARM64_OpBitRev32_0(v)
case OpBitRev64:
- return rewriteValueARM64_OpBitRev64(v)
+ return rewriteValueARM64_OpBitRev64_0(v)
case OpBitRev8:
- return rewriteValueARM64_OpBitRev8(v)
+ return rewriteValueARM64_OpBitRev8_0(v)
case OpBswap32:
- return rewriteValueARM64_OpBswap32(v)
+ return rewriteValueARM64_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueARM64_OpBswap64(v)
+ return rewriteValueARM64_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueARM64_OpClosureCall(v)
+ return rewriteValueARM64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueARM64_OpCom16(v)
+ return rewriteValueARM64_OpCom16_0(v)
case OpCom32:
- return rewriteValueARM64_OpCom32(v)
+ return rewriteValueARM64_OpCom32_0(v)
case OpCom64:
- return rewriteValueARM64_OpCom64(v)
+ return rewriteValueARM64_OpCom64_0(v)
case OpCom8:
- return rewriteValueARM64_OpCom8(v)
+ return rewriteValueARM64_OpCom8_0(v)
case OpConst16:
- return rewriteValueARM64_OpConst16(v)
+ return rewriteValueARM64_OpConst16_0(v)
case OpConst32:
- return rewriteValueARM64_OpConst32(v)
+ return rewriteValueARM64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueARM64_OpConst32F(v)
+ return rewriteValueARM64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueARM64_OpConst64(v)
+ return rewriteValueARM64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueARM64_OpConst64F(v)
+ return rewriteValueARM64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueARM64_OpConst8(v)
+ return rewriteValueARM64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueARM64_OpConstBool(v)
+ return rewriteValueARM64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueARM64_OpConstNil(v)
+ return rewriteValueARM64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueARM64_OpConvert(v)
+ return rewriteValueARM64_OpConvert_0(v)
case OpCtz32:
- return rewriteValueARM64_OpCtz32(v)
+ return rewriteValueARM64_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueARM64_OpCtz64(v)
+ return rewriteValueARM64_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueARM64_OpCvt32Fto32(v)
+ return rewriteValueARM64_OpCvt32Fto32_0(v)
case OpCvt32Fto32U:
- return rewriteValueARM64_OpCvt32Fto32U(v)
+ return rewriteValueARM64_OpCvt32Fto32U_0(v)
case OpCvt32Fto64:
- return rewriteValueARM64_OpCvt32Fto64(v)
+ return rewriteValueARM64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueARM64_OpCvt32Fto64F(v)
+ return rewriteValueARM64_OpCvt32Fto64F_0(v)
case OpCvt32Fto64U:
- return rewriteValueARM64_OpCvt32Fto64U(v)
+ return rewriteValueARM64_OpCvt32Fto64U_0(v)
case OpCvt32Uto32F:
- return rewriteValueARM64_OpCvt32Uto32F(v)
+ return rewriteValueARM64_OpCvt32Uto32F_0(v)
case OpCvt32Uto64F:
- return rewriteValueARM64_OpCvt32Uto64F(v)
+ return rewriteValueARM64_OpCvt32Uto64F_0(v)
case OpCvt32to32F:
- return rewriteValueARM64_OpCvt32to32F(v)
+ return rewriteValueARM64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueARM64_OpCvt32to64F(v)
+ return rewriteValueARM64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueARM64_OpCvt64Fto32(v)
+ return rewriteValueARM64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueARM64_OpCvt64Fto32F(v)
+ return rewriteValueARM64_OpCvt64Fto32F_0(v)
case OpCvt64Fto32U:
- return rewriteValueARM64_OpCvt64Fto32U(v)
+ return rewriteValueARM64_OpCvt64Fto32U_0(v)
case OpCvt64Fto64:
- return rewriteValueARM64_OpCvt64Fto64(v)
+ return rewriteValueARM64_OpCvt64Fto64_0(v)
case OpCvt64Fto64U:
- return rewriteValueARM64_OpCvt64Fto64U(v)
+ return rewriteValueARM64_OpCvt64Fto64U_0(v)
case OpCvt64Uto32F:
- return rewriteValueARM64_OpCvt64Uto32F(v)
+ return rewriteValueARM64_OpCvt64Uto32F_0(v)
case OpCvt64Uto64F:
- return rewriteValueARM64_OpCvt64Uto64F(v)
+ return rewriteValueARM64_OpCvt64Uto64F_0(v)
case OpCvt64to32F:
- return rewriteValueARM64_OpCvt64to32F(v)
+ return rewriteValueARM64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueARM64_OpCvt64to64F(v)
+ return rewriteValueARM64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueARM64_OpDiv16(v)
+ return rewriteValueARM64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueARM64_OpDiv16u(v)
+ return rewriteValueARM64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueARM64_OpDiv32(v)
+ return rewriteValueARM64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueARM64_OpDiv32F(v)
+ return rewriteValueARM64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueARM64_OpDiv32u(v)
+ return rewriteValueARM64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueARM64_OpDiv64(v)
+ return rewriteValueARM64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueARM64_OpDiv64F(v)
+ return rewriteValueARM64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueARM64_OpDiv64u(v)
+ return rewriteValueARM64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueARM64_OpDiv8(v)
+ return rewriteValueARM64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueARM64_OpDiv8u(v)
+ return rewriteValueARM64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueARM64_OpEq16(v)
+ return rewriteValueARM64_OpEq16_0(v)
case OpEq32:
- return rewriteValueARM64_OpEq32(v)
+ return rewriteValueARM64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueARM64_OpEq32F(v)
+ return rewriteValueARM64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueARM64_OpEq64(v)
+ return rewriteValueARM64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueARM64_OpEq64F(v)
+ return rewriteValueARM64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueARM64_OpEq8(v)
+ return rewriteValueARM64_OpEq8_0(v)
case OpEqB:
- return rewriteValueARM64_OpEqB(v)
+ return rewriteValueARM64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueARM64_OpEqPtr(v)
+ return rewriteValueARM64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueARM64_OpGeq16(v)
+ return rewriteValueARM64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueARM64_OpGeq16U(v)
+ return rewriteValueARM64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueARM64_OpGeq32(v)
+ return rewriteValueARM64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueARM64_OpGeq32F(v)
+ return rewriteValueARM64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueARM64_OpGeq32U(v)
+ return rewriteValueARM64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueARM64_OpGeq64(v)
+ return rewriteValueARM64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueARM64_OpGeq64F(v)
+ return rewriteValueARM64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueARM64_OpGeq64U(v)
+ return rewriteValueARM64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueARM64_OpGeq8(v)
+ return rewriteValueARM64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueARM64_OpGeq8U(v)
+ return rewriteValueARM64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueARM64_OpGetClosurePtr(v)
+ return rewriteValueARM64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueARM64_OpGreater16(v)
+ return rewriteValueARM64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueARM64_OpGreater16U(v)
+ return rewriteValueARM64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueARM64_OpGreater32(v)
+ return rewriteValueARM64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueARM64_OpGreater32F(v)
+ return rewriteValueARM64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueARM64_OpGreater32U(v)
+ return rewriteValueARM64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueARM64_OpGreater64(v)
+ return rewriteValueARM64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueARM64_OpGreater64F(v)
+ return rewriteValueARM64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueARM64_OpGreater64U(v)
+ return rewriteValueARM64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueARM64_OpGreater8(v)
+ return rewriteValueARM64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueARM64_OpGreater8U(v)
+ return rewriteValueARM64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueARM64_OpHmul32(v)
+ return rewriteValueARM64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueARM64_OpHmul32u(v)
+ return rewriteValueARM64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueARM64_OpHmul64(v)
+ return rewriteValueARM64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueARM64_OpHmul64u(v)
+ return rewriteValueARM64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValueARM64_OpInterCall(v)
+ return rewriteValueARM64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueARM64_OpIsInBounds(v)
+ return rewriteValueARM64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueARM64_OpIsNonNil(v)
+ return rewriteValueARM64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueARM64_OpIsSliceInBounds(v)
+ return rewriteValueARM64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueARM64_OpLeq16(v)
+ return rewriteValueARM64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueARM64_OpLeq16U(v)
+ return rewriteValueARM64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueARM64_OpLeq32(v)
+ return rewriteValueARM64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueARM64_OpLeq32F(v)
+ return rewriteValueARM64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueARM64_OpLeq32U(v)
+ return rewriteValueARM64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueARM64_OpLeq64(v)
+ return rewriteValueARM64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueARM64_OpLeq64F(v)
+ return rewriteValueARM64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueARM64_OpLeq64U(v)
+ return rewriteValueARM64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueARM64_OpLeq8(v)
+ return rewriteValueARM64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueARM64_OpLeq8U(v)
+ return rewriteValueARM64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueARM64_OpLess16(v)
+ return rewriteValueARM64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueARM64_OpLess16U(v)
+ return rewriteValueARM64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueARM64_OpLess32(v)
+ return rewriteValueARM64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueARM64_OpLess32F(v)
+ return rewriteValueARM64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueARM64_OpLess32U(v)
+ return rewriteValueARM64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueARM64_OpLess64(v)
+ return rewriteValueARM64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueARM64_OpLess64F(v)
+ return rewriteValueARM64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueARM64_OpLess64U(v)
+ return rewriteValueARM64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueARM64_OpLess8(v)
+ return rewriteValueARM64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueARM64_OpLess8U(v)
+ return rewriteValueARM64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueARM64_OpLoad(v)
+ return rewriteValueARM64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueARM64_OpLsh16x16(v)
+ return rewriteValueARM64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueARM64_OpLsh16x32(v)
+ return rewriteValueARM64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueARM64_OpLsh16x64(v)
+ return rewriteValueARM64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueARM64_OpLsh16x8(v)
+ return rewriteValueARM64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueARM64_OpLsh32x16(v)
+ return rewriteValueARM64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueARM64_OpLsh32x32(v)
+ return rewriteValueARM64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueARM64_OpLsh32x64(v)
+ return rewriteValueARM64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueARM64_OpLsh32x8(v)
+ return rewriteValueARM64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueARM64_OpLsh64x16(v)
+ return rewriteValueARM64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueARM64_OpLsh64x32(v)
+ return rewriteValueARM64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueARM64_OpLsh64x64(v)
+ return rewriteValueARM64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueARM64_OpLsh64x8(v)
+ return rewriteValueARM64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueARM64_OpLsh8x16(v)
+ return rewriteValueARM64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueARM64_OpLsh8x32(v)
+ return rewriteValueARM64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueARM64_OpLsh8x64(v)
+ return rewriteValueARM64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueARM64_OpLsh8x8(v)
+ return rewriteValueARM64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueARM64_OpMod16(v)
+ return rewriteValueARM64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueARM64_OpMod16u(v)
+ return rewriteValueARM64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueARM64_OpMod32(v)
+ return rewriteValueARM64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueARM64_OpMod32u(v)
+ return rewriteValueARM64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueARM64_OpMod64(v)
+ return rewriteValueARM64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueARM64_OpMod64u(v)
+ return rewriteValueARM64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueARM64_OpMod8(v)
+ return rewriteValueARM64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueARM64_OpMod8u(v)
+ return rewriteValueARM64_OpMod8u_0(v)
case OpMove:
- return rewriteValueARM64_OpMove(v)
+ return rewriteValueARM64_OpMove_0(v) || rewriteValueARM64_OpMove_10(v)
case OpMul16:
- return rewriteValueARM64_OpMul16(v)
+ return rewriteValueARM64_OpMul16_0(v)
case OpMul32:
- return rewriteValueARM64_OpMul32(v)
+ return rewriteValueARM64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueARM64_OpMul32F(v)
+ return rewriteValueARM64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueARM64_OpMul64(v)
+ return rewriteValueARM64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueARM64_OpMul64F(v)
+ return rewriteValueARM64_OpMul64F_0(v)
case OpMul8:
- return rewriteValueARM64_OpMul8(v)
+ return rewriteValueARM64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueARM64_OpNeg16(v)
+ return rewriteValueARM64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueARM64_OpNeg32(v)
+ return rewriteValueARM64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueARM64_OpNeg32F(v)
+ return rewriteValueARM64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueARM64_OpNeg64(v)
+ return rewriteValueARM64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueARM64_OpNeg64F(v)
+ return rewriteValueARM64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueARM64_OpNeg8(v)
+ return rewriteValueARM64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueARM64_OpNeq16(v)
+ return rewriteValueARM64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueARM64_OpNeq32(v)
+ return rewriteValueARM64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueARM64_OpNeq32F(v)
+ return rewriteValueARM64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueARM64_OpNeq64(v)
+ return rewriteValueARM64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueARM64_OpNeq64F(v)
+ return rewriteValueARM64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueARM64_OpNeq8(v)
+ return rewriteValueARM64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueARM64_OpNeqB(v)
+ return rewriteValueARM64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueARM64_OpNeqPtr(v)
+ return rewriteValueARM64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueARM64_OpNilCheck(v)
+ return rewriteValueARM64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueARM64_OpNot(v)
+ return rewriteValueARM64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueARM64_OpOffPtr(v)
+ return rewriteValueARM64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueARM64_OpOr16(v)
+ return rewriteValueARM64_OpOr16_0(v)
case OpOr32:
- return rewriteValueARM64_OpOr32(v)
+ return rewriteValueARM64_OpOr32_0(v)
case OpOr64:
- return rewriteValueARM64_OpOr64(v)
+ return rewriteValueARM64_OpOr64_0(v)
case OpOr8:
- return rewriteValueARM64_OpOr8(v)
+ return rewriteValueARM64_OpOr8_0(v)
case OpOrB:
- return rewriteValueARM64_OpOrB(v)
+ return rewriteValueARM64_OpOrB_0(v)
case OpRound32F:
- return rewriteValueARM64_OpRound32F(v)
+ return rewriteValueARM64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueARM64_OpRound64F(v)
+ return rewriteValueARM64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueARM64_OpRsh16Ux16(v)
+ return rewriteValueARM64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueARM64_OpRsh16Ux32(v)
+ return rewriteValueARM64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueARM64_OpRsh16Ux64(v)
+ return rewriteValueARM64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueARM64_OpRsh16Ux8(v)
+ return rewriteValueARM64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueARM64_OpRsh16x16(v)
+ return rewriteValueARM64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueARM64_OpRsh16x32(v)
+ return rewriteValueARM64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueARM64_OpRsh16x64(v)
+ return rewriteValueARM64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueARM64_OpRsh16x8(v)
+ return rewriteValueARM64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueARM64_OpRsh32Ux16(v)
+ return rewriteValueARM64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueARM64_OpRsh32Ux32(v)
+ return rewriteValueARM64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueARM64_OpRsh32Ux64(v)
+ return rewriteValueARM64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueARM64_OpRsh32Ux8(v)
+ return rewriteValueARM64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueARM64_OpRsh32x16(v)
+ return rewriteValueARM64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueARM64_OpRsh32x32(v)
+ return rewriteValueARM64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueARM64_OpRsh32x64(v)
+ return rewriteValueARM64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueARM64_OpRsh32x8(v)
+ return rewriteValueARM64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueARM64_OpRsh64Ux16(v)
+ return rewriteValueARM64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueARM64_OpRsh64Ux32(v)
+ return rewriteValueARM64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueARM64_OpRsh64Ux64(v)
+ return rewriteValueARM64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueARM64_OpRsh64Ux8(v)
+ return rewriteValueARM64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueARM64_OpRsh64x16(v)
+ return rewriteValueARM64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueARM64_OpRsh64x32(v)
+ return rewriteValueARM64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueARM64_OpRsh64x64(v)
+ return rewriteValueARM64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueARM64_OpRsh64x8(v)
+ return rewriteValueARM64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueARM64_OpRsh8Ux16(v)
+ return rewriteValueARM64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueARM64_OpRsh8Ux32(v)
+ return rewriteValueARM64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueARM64_OpRsh8Ux64(v)
+ return rewriteValueARM64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueARM64_OpRsh8Ux8(v)
+ return rewriteValueARM64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueARM64_OpRsh8x16(v)
+ return rewriteValueARM64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueARM64_OpRsh8x32(v)
+ return rewriteValueARM64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueARM64_OpRsh8x64(v)
+ return rewriteValueARM64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueARM64_OpRsh8x8(v)
+ return rewriteValueARM64_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValueARM64_OpSignExt16to32(v)
+ return rewriteValueARM64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueARM64_OpSignExt16to64(v)
+ return rewriteValueARM64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueARM64_OpSignExt32to64(v)
+ return rewriteValueARM64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueARM64_OpSignExt8to16(v)
+ return rewriteValueARM64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueARM64_OpSignExt8to32(v)
+ return rewriteValueARM64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueARM64_OpSignExt8to64(v)
+ return rewriteValueARM64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueARM64_OpSlicemask(v)
+ return rewriteValueARM64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueARM64_OpSqrt(v)
+ return rewriteValueARM64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueARM64_OpStaticCall(v)
+ return rewriteValueARM64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueARM64_OpStore(v)
+ return rewriteValueARM64_OpStore_0(v)
case OpSub16:
- return rewriteValueARM64_OpSub16(v)
+ return rewriteValueARM64_OpSub16_0(v)
case OpSub32:
- return rewriteValueARM64_OpSub32(v)
+ return rewriteValueARM64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueARM64_OpSub32F(v)
+ return rewriteValueARM64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueARM64_OpSub64(v)
+ return rewriteValueARM64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueARM64_OpSub64F(v)
+ return rewriteValueARM64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueARM64_OpSub8(v)
+ return rewriteValueARM64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueARM64_OpSubPtr(v)
+ return rewriteValueARM64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueARM64_OpTrunc16to8(v)
+ return rewriteValueARM64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueARM64_OpTrunc32to16(v)
+ return rewriteValueARM64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueARM64_OpTrunc32to8(v)
+ return rewriteValueARM64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueARM64_OpTrunc64to16(v)
+ return rewriteValueARM64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueARM64_OpTrunc64to32(v)
+ return rewriteValueARM64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueARM64_OpTrunc64to8(v)
+ return rewriteValueARM64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueARM64_OpXor16(v)
+ return rewriteValueARM64_OpXor16_0(v)
case OpXor32:
- return rewriteValueARM64_OpXor32(v)
+ return rewriteValueARM64_OpXor32_0(v)
case OpXor64:
- return rewriteValueARM64_OpXor64(v)
+ return rewriteValueARM64_OpXor64_0(v)
case OpXor8:
- return rewriteValueARM64_OpXor8(v)
+ return rewriteValueARM64_OpXor8_0(v)
case OpZero:
- return rewriteValueARM64_OpZero(v)
+ return rewriteValueARM64_OpZero_0(v) || rewriteValueARM64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueARM64_OpZeroExt16to32(v)
+ return rewriteValueARM64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueARM64_OpZeroExt16to64(v)
+ return rewriteValueARM64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueARM64_OpZeroExt32to64(v)
+ return rewriteValueARM64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueARM64_OpZeroExt8to16(v)
+ return rewriteValueARM64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueARM64_OpZeroExt8to32(v)
+ return rewriteValueARM64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueARM64_OpZeroExt8to64(v)
+ return rewriteValueARM64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueARM64_OpARM64ADD(v *Value) bool {
+func rewriteValueARM64_OpARM64ADD_0(v *Value) bool {
// match: (ADD x (MOVDconst [c]))
// cond:
// result: (ADDconst [c] x)
}
return false
}
-func rewriteValueARM64_OpARM64ADDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr))
// cond:
// result: (MOVDaddr [off1+off2] {sym} ptr)
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftLL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRA (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ADDshiftRL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64AND(v *Value) bool {
+func rewriteValueARM64_OpARM64AND_0(v *Value) bool {
// match: (AND x (MOVDconst [c]))
// cond:
// result: (ANDconst [c] x)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64AND_10(v *Value) bool {
// match: (AND (SRAconst [c] y) x)
// cond:
// result: (ANDshiftRA x y [c])
}
return false
}
-func rewriteValueARM64_OpARM64ANDconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftLL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRA (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ANDshiftRL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64BIC(v *Value) bool {
+func rewriteValueARM64_OpARM64BIC_0(v *Value) bool {
// match: (BIC x (MOVDconst [c]))
// cond:
// result: (BICconst [c] x)
}
return false
}
-func rewriteValueARM64_OpARM64BICconst(v *Value) bool {
+func rewriteValueARM64_OpARM64BICconst_0(v *Value) bool {
// match: (BICconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftLL_0(v *Value) bool {
// match: (BICshiftLL x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint64(c)<<uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRA_0(v *Value) bool {
// match: (BICshiftRA x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(int64(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool {
// match: (BICshiftRL x (MOVDconst [c]) [d])
// cond:
// result: (BICconst x [int64(uint64(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64CMP(v *Value) bool {
+func rewriteValueARM64_OpARM64CMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
}
return false
}
-func rewriteValueARM64_OpARM64CMPW(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVDconst [c]))
}
return false
}
-func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueARM64_OpARM64CMPconst(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
// result: (FlagEQ)
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftLL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRA (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPshiftRL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64CSELULT(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT_0(v *Value) bool {
// match: (CSELULT x (MOVDconst [0]) flag)
// cond:
// result: (CSELULT0 x flag)
}
return false
}
-func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool {
+func rewriteValueARM64_OpARM64CSELULT0_0(v *Value) bool {
// match: (CSELULT0 _ (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64DIV(v *Value) bool {
+func rewriteValueARM64_OpARM64DIV_0(v *Value) bool {
// match: (DIV (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(c)/int64(d)])
}
return false
}
-func rewriteValueARM64_OpARM64DIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool {
// match: (DIVW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)/int32(d))])
}
return false
}
-func rewriteValueARM64_OpARM64Equal(v *Value) bool {
+func rewriteValueARM64_OpARM64Equal_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (FMOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (FMOVSload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool {
+func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool {
// match: (GreaterEqualU (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool {
// match: (GreaterThanU (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64LessEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool {
// match: (LessEqualU (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValueARM64_OpARM64LessThan(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64LessThanU(v *Value) bool {
+func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool {
// match: (LessThanU (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64MOD(v *Value) bool {
+func rewriteValueARM64_OpARM64MOD_0(v *Value) bool {
// match: (MOD (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(c)%int64(d)])
}
return false
}
-func rewriteValueARM64_OpARM64MODW(v *Value) bool {
+func rewriteValueARM64_OpARM64MODW_0(v *Value) bool {
// match: (MODW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)%int32(d))])
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVBload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 1, sym)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVDload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool {
// match: (MOVDreg x)
// cond: x.Uses == 1
// result: (MOVDnop x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool {
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 8, sym)
// result: (MOVDstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 2, sym)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool {
// match: (MOVWUload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool {
// match: (MOVWUreg x:(MOVBUload _ _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueARM64_OpARM64MOVWload(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool {
// match: (MOVWreg (MOVDconst [c]))
// cond:
// result: (MOVDconst [int64(int32(c))])
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool {
+func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: fitsARM64Offset(off1+off2, 4, sym)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueARM64_OpARM64MUL(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM64_OpARM64MUL_0(v *Value) bool {
// match: (MUL x (MOVDconst [-1]))
// cond:
// result: (NEG x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MUL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MUL x (MOVDconst [c]))
// cond: isPowerOfTwo(c+1) && c >= 7
// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MUL_20(v *Value) bool {
// match: (MUL (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [c*d])
}
return false
}
-func rewriteValueARM64_OpARM64MULW(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueARM64_OpARM64MULW_0(v *Value) bool {
// match: (MULW x (MOVDconst [c]))
// cond: int32(c)==-1
// result: (NEG x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MULW_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MULW x (MOVDconst [c]))
// cond: isPowerOfTwo(c+1) && int32(c) >= 7
// result: (ADDshiftLL (NEG <x.Type> x) x [log2(c+1)])
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64MULW_20(v *Value) bool {
// match: (MULW (MOVDconst [c]) (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(int32(c)*int32(d))])
}
return false
}
-func rewriteValueARM64_OpARM64MVN(v *Value) bool {
+func rewriteValueARM64_OpARM64MVN_0(v *Value) bool {
// match: (MVN (MOVDconst [c]))
// cond:
// result: (MOVDconst [^c])
}
return false
}
-func rewriteValueARM64_OpARM64NEG(v *Value) bool {
+func rewriteValueARM64_OpARM64NEG_0(v *Value) bool {
// match: (NEG (MOVDconst [c]))
// cond:
// result: (MOVDconst [-c])
}
return false
}
-func rewriteValueARM64_OpARM64NotEqual(v *Value) bool {
+func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64OR(v *Value) bool {
+func rewriteValueARM64_OpARM64OR_0(v *Value) bool {
b := v.Block
_ = b
// match: (OR x (MOVDconst [c]))
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64OR_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (OR <t> y3:(MOVDnop x3:(MOVBUload [i0] {s} p mem)) o0:(ORshiftLL [8] o1:(ORshiftLL [16] s0:(SLLconst [24] y0:(MOVDnop x0:(MOVBUload [i3] {s} p mem))) y1:(MOVDnop x1:(MOVBUload [i2] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i1] {s} p mem))))
// cond: i1 == i0+1 && i2 == i0+2 && i3 == i0+3 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 && o0.Uses == 1 && o1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1,x2,x3) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) && clobber(o0) && clobber(o1) && clobber(s0)
// result: @mergePoint(b,x0,x1,x2,x3) (MOVWUload <t> {s} (OffPtr <p.Type> [i0] p) mem)
}
return false
}
-func rewriteValueARM64_OpARM64ORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftLL (MOVDconst [c]) x [d])
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (ORshiftLL <t> [56] o0:(ORshiftLL [48] o1:(ORshiftLL [40] o2:(ORshiftLL [32] y0:(REVW x0:(MOVWUload [i4] {s} p mem)) y1:(MOVDnop x1:(MOVBUload [i3] {s} p mem))) y2:(MOVDnop x2:(MOVBUload [i2] {s} p mem))) y3:(MOVDnop x3:(MOVBUload [i1] {s} p mem))) y4:(MOVDnop x4:(MOVBUload [i0] {s} p mem)))
// cond: i1 == i0+1 && i2 == i0+2 && i3 == i0+3 && i4 == i0+4 && x0.Uses == 1 && x1.Uses == 1 && x2.Uses == 1 && x3.Uses == 1 && x4.Uses == 1 && y0.Uses == 1 && y1.Uses == 1 && y2.Uses == 1 && y3.Uses == 1 && y4.Uses == 1 && o0.Uses == 1 && o1.Uses == 1 && o2.Uses == 1 && mergePoint(b,x0,x1,x2,x3,x4) != nil && clobber(x0) && clobber(x1) && clobber(x2) && clobber(x3) && clobber(x4) && clobber(y0) && clobber(y1) && clobber(y2) && clobber(y3) && clobber(y4) && clobber(o0) && clobber(o1) && clobber(o2)
// result: @mergePoint(b,x0,x1,x2,x3,x4) (REV <t> (MOVDload <t> {s} (OffPtr <p.Type> [i0] p) mem))
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRA (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (ORshiftRL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64SLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SLL_0(v *Value) bool {
// match: (SLL x (MOVDconst [c]))
// cond:
// result: (SLLconst x [c&63])
}
return false
}
-func rewriteValueARM64_OpARM64SLLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(d)<<uint64(c)])
}
return false
}
-func rewriteValueARM64_OpARM64SRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SRA_0(v *Value) bool {
// match: (SRA x (MOVDconst [c]))
// cond:
// result: (SRAconst x [c&63])
}
return false
}
-func rewriteValueARM64_OpARM64SRAconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(d)>>uint64(c)])
}
return false
}
-func rewriteValueARM64_OpARM64SRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SRL_0(v *Value) bool {
// match: (SRL x (MOVDconst [c]))
// cond:
// result: (SRLconst x [c&63])
}
return false
}
-func rewriteValueARM64_OpARM64SRLconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [int64(uint64(d)>>uint64(c))])
}
return false
}
-func rewriteValueARM64_OpARM64SUB(v *Value) bool {
+func rewriteValueARM64_OpARM64SUB_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUB x (MOVDconst [c]))
}
return false
}
-func rewriteValueARM64_OpARM64SUBconst(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftLL_0(v *Value) bool {
// match: (SUBshiftLL x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(uint64(c)<<uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRA_0(v *Value) bool {
// match: (SUBshiftRA x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(int64(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool {
// match: (SUBshiftRL x (MOVDconst [c]) [d])
// cond:
// result: (SUBconst x [int64(uint64(c)>>uint64(d))])
}
return false
}
-func rewriteValueARM64_OpARM64UDIV(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool {
// match: (UDIV x (MOVDconst [1]))
// cond:
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64UDIVW(v *Value) bool {
+func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool {
// match: (UDIVW x (MOVDconst [c]))
// cond: uint32(c)==1
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64UMOD(v *Value) bool {
+func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool {
// match: (UMOD _ (MOVDconst [1]))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64UMODW(v *Value) bool {
+func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool {
// match: (UMODW _ (MOVDconst [c]))
// cond: uint32(c)==1
// result: (MOVDconst [0])
}
return false
}
-func rewriteValueARM64_OpARM64XOR(v *Value) bool {
+func rewriteValueARM64_OpARM64XOR_0(v *Value) bool {
// match: (XOR x (MOVDconst [c]))
// cond:
// result: (XORconst [c] x)
}
return false
}
-func rewriteValueARM64_OpARM64XORconst(v *Value) bool {
+func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftLL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRA (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool {
+func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool {
b := v.Block
_ = b
// match: (XORshiftRL (MOVDconst [c]) x [d])
}
return false
}
-func rewriteValueARM64_OpAdd16(v *Value) bool {
+func rewriteValueARM64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM64_OpAdd32(v *Value) bool {
+func rewriteValueARM64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM64_OpAdd32F(v *Value) bool {
+func rewriteValueARM64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
return true
}
}
-func rewriteValueARM64_OpAdd64(v *Value) bool {
+func rewriteValueARM64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM64_OpAdd64F(v *Value) bool {
+func rewriteValueARM64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADDD x y)
return true
}
}
-func rewriteValueARM64_OpAdd8(v *Value) bool {
+func rewriteValueARM64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM64_OpAddPtr(v *Value) bool {
+func rewriteValueARM64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueARM64_OpAddr(v *Value) bool {
+func rewriteValueARM64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
return true
}
}
-func rewriteValueARM64_OpAnd16(v *Value) bool {
+func rewriteValueARM64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM64_OpAnd32(v *Value) bool {
+func rewriteValueARM64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM64_OpAnd64(v *Value) bool {
+func rewriteValueARM64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM64_OpAnd8(v *Value) bool {
+func rewriteValueARM64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM64_OpAndB(v *Value) bool {
+func rewriteValueARM64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueARM64_OpAtomicAdd32(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd32 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicAdd64(v *Value) bool {
+func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool {
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (LoweredAtomicAdd64 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicAnd8(v *Value) bool {
+func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (LoweredAtomicAnd8 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
return true
}
}
-func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
return true
}
}
-func rewriteValueARM64_OpAtomicExchange32(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicExchange64(v *Value) bool {
+func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicLoad32(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LDARW ptr mem)
return true
}
}
-func rewriteValueARM64_OpAtomicLoad64(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (LDAR ptr mem)
return true
}
}
-func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LDAR ptr mem)
return true
}
}
-func rewriteValueARM64_OpAtomicOr8(v *Value) bool {
+func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (LoweredAtomicOr8 ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicStore32(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (STLRW ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicStore64(v *Value) bool {
+func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (STLR ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (STLR ptr val mem)
return true
}
}
-func rewriteValueARM64_OpAvg64u(v *Value) bool {
+func rewriteValueARM64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
return true
}
}
-func rewriteValueARM64_OpBitLen64(v *Value) bool {
+func rewriteValueARM64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpBitRev16(v *Value) bool {
+func rewriteValueARM64_OpBitRev16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpBitRev32(v *Value) bool {
+func rewriteValueARM64_OpBitRev32_0(v *Value) bool {
// match: (BitRev32 x)
// cond:
// result: (RBITW x)
return true
}
}
-func rewriteValueARM64_OpBitRev64(v *Value) bool {
+func rewriteValueARM64_OpBitRev64_0(v *Value) bool {
// match: (BitRev64 x)
// cond:
// result: (RBIT x)
return true
}
}
-func rewriteValueARM64_OpBitRev8(v *Value) bool {
+func rewriteValueARM64_OpBitRev8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpBswap32(v *Value) bool {
+func rewriteValueARM64_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (REVW x)
return true
}
}
-func rewriteValueARM64_OpBswap64(v *Value) bool {
+func rewriteValueARM64_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (REV x)
return true
}
}
-func rewriteValueARM64_OpClosureCall(v *Value) bool {
+func rewriteValueARM64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueARM64_OpCom16(v *Value) bool {
+func rewriteValueARM64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM64_OpCom32(v *Value) bool {
+func rewriteValueARM64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM64_OpCom64(v *Value) bool {
+func rewriteValueARM64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM64_OpCom8(v *Value) bool {
+func rewriteValueARM64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (MVN x)
return true
}
}
-func rewriteValueARM64_OpConst16(v *Value) bool {
+func rewriteValueARM64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueARM64_OpConst32(v *Value) bool {
+func rewriteValueARM64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueARM64_OpConst32F(v *Value) bool {
+func rewriteValueARM64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
return true
}
}
-func rewriteValueARM64_OpConst64(v *Value) bool {
+func rewriteValueARM64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueARM64_OpConst64F(v *Value) bool {
+func rewriteValueARM64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
return true
}
}
-func rewriteValueARM64_OpConst8(v *Value) bool {
+func rewriteValueARM64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueARM64_OpConstBool(v *Value) bool {
+func rewriteValueARM64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
return true
}
}
-func rewriteValueARM64_OpConstNil(v *Value) bool {
+func rewriteValueARM64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
return true
}
}
-func rewriteValueARM64_OpConvert(v *Value) bool {
+func rewriteValueARM64_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVDconvert x mem)
return true
}
}
-func rewriteValueARM64_OpCtz32(v *Value) bool {
+func rewriteValueARM64_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz32 <t> x)
return true
}
}
-func rewriteValueARM64_OpCtz64(v *Value) bool {
+func rewriteValueARM64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Ctz64 <t> x)
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (FCVTZSSW x)
return true
}
}
-func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool {
// match: (Cvt32Fto32U x)
// cond:
// result: (FCVTZUSW x)
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (FCVTZSS x)
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (FCVTSD x)
return true
}
}
-func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool {
// match: (Cvt32Fto64U x)
// cond:
// result: (FCVTZUS x)
return true
}
}
-func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool {
// match: (Cvt32Uto32F x)
// cond:
// result: (UCVTFWS x)
return true
}
}
-func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool {
// match: (Cvt32Uto64F x)
// cond:
// result: (UCVTFWD x)
return true
}
}
-func rewriteValueARM64_OpCvt32to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (SCVTFWS x)
return true
}
}
-func rewriteValueARM64_OpCvt32to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (SCVTFWD x)
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (FCVTZSDW x)
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (FCVTDS x)
return true
}
}
-func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool {
// match: (Cvt64Fto32U x)
// cond:
// result: (FCVTZUDW x)
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (FCVTZSD x)
return true
}
}
-func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool {
+func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool {
// match: (Cvt64Fto64U x)
// cond:
// result: (FCVTZUD x)
return true
}
}
-func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool {
// match: (Cvt64Uto32F x)
// cond:
// result: (UCVTFS x)
return true
}
}
-func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool {
// match: (Cvt64Uto64F x)
// cond:
// result: (UCVTFD x)
return true
}
}
-func rewriteValueARM64_OpCvt64to32F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (SCVTFS x)
return true
}
}
-func rewriteValueARM64_OpCvt64to64F(v *Value) bool {
+func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (SCVTFD x)
return true
}
}
-func rewriteValueARM64_OpDiv16(v *Value) bool {
+func rewriteValueARM64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpDiv16u(v *Value) bool {
+func rewriteValueARM64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpDiv32(v *Value) bool {
+func rewriteValueARM64_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVW x y)
return true
}
}
-func rewriteValueARM64_OpDiv32F(v *Value) bool {
+func rewriteValueARM64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
return true
}
}
-func rewriteValueARM64_OpDiv32u(v *Value) bool {
+func rewriteValueARM64_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (UDIVW x y)
return true
}
}
-func rewriteValueARM64_OpDiv64(v *Value) bool {
+func rewriteValueARM64_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIV x y)
return true
}
}
-func rewriteValueARM64_OpDiv64F(v *Value) bool {
+func rewriteValueARM64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIVD x y)
return true
}
}
-func rewriteValueARM64_OpDiv64u(v *Value) bool {
+func rewriteValueARM64_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (UDIV x y)
return true
}
}
-func rewriteValueARM64_OpDiv8(v *Value) bool {
+func rewriteValueARM64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpDiv8u(v *Value) bool {
+func rewriteValueARM64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpEq16(v *Value) bool {
+func rewriteValueARM64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpEq32(v *Value) bool {
+func rewriteValueARM64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
return true
}
}
-func rewriteValueARM64_OpEq32F(v *Value) bool {
+func rewriteValueARM64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValueARM64_OpEq64(v *Value) bool {
+func rewriteValueARM64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
return true
}
}
-func rewriteValueARM64_OpEq64F(v *Value) bool {
+func rewriteValueARM64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValueARM64_OpEq8(v *Value) bool {
+func rewriteValueARM64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpEqB(v *Value) bool {
+func rewriteValueARM64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpEqPtr(v *Value) bool {
+func rewriteValueARM64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
return true
}
}
-func rewriteValueARM64_OpGeq16(v *Value) bool {
+func rewriteValueARM64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGeq16U(v *Value) bool {
+func rewriteValueARM64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGeq32(v *Value) bool {
+func rewriteValueARM64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
return true
}
}
-func rewriteValueARM64_OpGeq32F(v *Value) bool {
+func rewriteValueARM64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValueARM64_OpGeq32U(v *Value) bool {
+func rewriteValueARM64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
return true
}
}
-func rewriteValueARM64_OpGeq64(v *Value) bool {
+func rewriteValueARM64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
return true
}
}
-func rewriteValueARM64_OpGeq64F(v *Value) bool {
+func rewriteValueARM64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValueARM64_OpGeq64U(v *Value) bool {
+func rewriteValueARM64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
return true
}
}
-func rewriteValueARM64_OpGeq8(v *Value) bool {
+func rewriteValueARM64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGeq8U(v *Value) bool {
+func rewriteValueARM64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueARM64_OpGreater16(v *Value) bool {
+func rewriteValueARM64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGreater16U(v *Value) bool {
+func rewriteValueARM64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGreater32(v *Value) bool {
+func rewriteValueARM64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
return true
}
}
-func rewriteValueARM64_OpGreater32F(v *Value) bool {
+func rewriteValueARM64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValueARM64_OpGreater32U(v *Value) bool {
+func rewriteValueARM64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
return true
}
}
-func rewriteValueARM64_OpGreater64(v *Value) bool {
+func rewriteValueARM64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
return true
}
}
-func rewriteValueARM64_OpGreater64F(v *Value) bool {
+func rewriteValueARM64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValueARM64_OpGreater64U(v *Value) bool {
+func rewriteValueARM64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
return true
}
}
-func rewriteValueARM64_OpGreater8(v *Value) bool {
+func rewriteValueARM64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpGreater8U(v *Value) bool {
+func rewriteValueARM64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpHmul32(v *Value) bool {
+func rewriteValueARM64_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpHmul32u(v *Value) bool {
+func rewriteValueARM64_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpHmul64(v *Value) bool {
+func rewriteValueARM64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULH x y)
return true
}
}
-func rewriteValueARM64_OpHmul64u(v *Value) bool {
+func rewriteValueARM64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (UMULH x y)
return true
}
}
-func rewriteValueARM64_OpInterCall(v *Value) bool {
+func rewriteValueARM64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueARM64_OpIsInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
return true
}
}
-func rewriteValueARM64_OpIsNonNil(v *Value) bool {
+func rewriteValueARM64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
return true
}
}
-func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
return true
}
}
-func rewriteValueARM64_OpLeq16(v *Value) bool {
+func rewriteValueARM64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLeq16U(v *Value) bool {
+func rewriteValueARM64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLeq32(v *Value) bool {
+func rewriteValueARM64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
return true
}
}
-func rewriteValueARM64_OpLeq32F(v *Value) bool {
+func rewriteValueARM64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValueARM64_OpLeq32U(v *Value) bool {
+func rewriteValueARM64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
return true
}
}
-func rewriteValueARM64_OpLeq64(v *Value) bool {
+func rewriteValueARM64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
return true
}
}
-func rewriteValueARM64_OpLeq64F(v *Value) bool {
+func rewriteValueARM64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValueARM64_OpLeq64U(v *Value) bool {
+func rewriteValueARM64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
return true
}
}
-func rewriteValueARM64_OpLeq8(v *Value) bool {
+func rewriteValueARM64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLeq8U(v *Value) bool {
+func rewriteValueARM64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLess16(v *Value) bool {
+func rewriteValueARM64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLess16U(v *Value) bool {
+func rewriteValueARM64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLess32(v *Value) bool {
+func rewriteValueARM64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
return true
}
}
-func rewriteValueARM64_OpLess32F(v *Value) bool {
+func rewriteValueARM64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValueARM64_OpLess32U(v *Value) bool {
+func rewriteValueARM64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
return true
}
}
-func rewriteValueARM64_OpLess64(v *Value) bool {
+func rewriteValueARM64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
return true
}
}
-func rewriteValueARM64_OpLess64F(v *Value) bool {
+func rewriteValueARM64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValueARM64_OpLess64U(v *Value) bool {
+func rewriteValueARM64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
return true
}
}
-func rewriteValueARM64_OpLess8(v *Value) bool {
+func rewriteValueARM64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLess8U(v *Value) bool {
+func rewriteValueARM64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLoad(v *Value) bool {
+func rewriteValueARM64_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
}
return false
}
-func rewriteValueARM64_OpLsh16x16(v *Value) bool {
+func rewriteValueARM64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh16x32(v *Value) bool {
+func rewriteValueARM64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh16x64(v *Value) bool {
+func rewriteValueARM64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpLsh16x8(v *Value) bool {
+func rewriteValueARM64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh32x16(v *Value) bool {
+func rewriteValueARM64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh32x32(v *Value) bool {
+func rewriteValueARM64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh32x64(v *Value) bool {
+func rewriteValueARM64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpLsh32x8(v *Value) bool {
+func rewriteValueARM64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh64x16(v *Value) bool {
+func rewriteValueARM64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh64x32(v *Value) bool {
+func rewriteValueARM64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh64x64(v *Value) bool {
+func rewriteValueARM64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpLsh64x8(v *Value) bool {
+func rewriteValueARM64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh8x16(v *Value) bool {
+func rewriteValueARM64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh8x32(v *Value) bool {
+func rewriteValueARM64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpLsh8x64(v *Value) bool {
+func rewriteValueARM64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpLsh8x8(v *Value) bool {
+func rewriteValueARM64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpMod16(v *Value) bool {
+func rewriteValueARM64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpMod16u(v *Value) bool {
+func rewriteValueARM64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpMod32(v *Value) bool {
+func rewriteValueARM64_OpMod32_0(v *Value) bool {
// match: (Mod32 x y)
// cond:
// result: (MODW x y)
return true
}
}
-func rewriteValueARM64_OpMod32u(v *Value) bool {
+func rewriteValueARM64_OpMod32u_0(v *Value) bool {
// match: (Mod32u x y)
// cond:
// result: (UMODW x y)
return true
}
}
-func rewriteValueARM64_OpMod64(v *Value) bool {
+func rewriteValueARM64_OpMod64_0(v *Value) bool {
// match: (Mod64 x y)
// cond:
// result: (MOD x y)
return true
}
}
-func rewriteValueARM64_OpMod64u(v *Value) bool {
+func rewriteValueARM64_OpMod64u_0(v *Value) bool {
// match: (Mod64u x y)
// cond:
// result: (UMOD x y)
return true
}
}
-func rewriteValueARM64_OpMod8(v *Value) bool {
+func rewriteValueARM64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpMod8u(v *Value) bool {
+func rewriteValueARM64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpMove(v *Value) bool {
+func rewriteValueARM64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [16] dst src mem)
// cond:
// result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem))
}
return false
}
-func rewriteValueARM64_OpMul16(v *Value) bool {
+func rewriteValueARM64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULW x y)
return true
}
}
-func rewriteValueARM64_OpMul32(v *Value) bool {
+func rewriteValueARM64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULW x y)
return true
}
}
-func rewriteValueARM64_OpMul32F(v *Value) bool {
+func rewriteValueARM64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
return true
}
}
-func rewriteValueARM64_OpMul64(v *Value) bool {
+func rewriteValueARM64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueARM64_OpMul64F(v *Value) bool {
+func rewriteValueARM64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMULD x y)
return true
}
}
-func rewriteValueARM64_OpMul8(v *Value) bool {
+func rewriteValueARM64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULW x y)
return true
}
}
-func rewriteValueARM64_OpNeg16(v *Value) bool {
+func rewriteValueARM64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueARM64_OpNeg32(v *Value) bool {
+func rewriteValueARM64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueARM64_OpNeg32F(v *Value) bool {
+func rewriteValueARM64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEGS x)
return true
}
}
-func rewriteValueARM64_OpNeg64(v *Value) bool {
+func rewriteValueARM64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueARM64_OpNeg64F(v *Value) bool {
+func rewriteValueARM64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEGD x)
return true
}
}
-func rewriteValueARM64_OpNeg8(v *Value) bool {
+func rewriteValueARM64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueARM64_OpNeq16(v *Value) bool {
+func rewriteValueARM64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpNeq32(v *Value) bool {
+func rewriteValueARM64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
return true
}
}
-func rewriteValueARM64_OpNeq32F(v *Value) bool {
+func rewriteValueARM64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValueARM64_OpNeq64(v *Value) bool {
+func rewriteValueARM64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
return true
}
}
-func rewriteValueARM64_OpNeq64F(v *Value) bool {
+func rewriteValueARM64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValueARM64_OpNeq8(v *Value) bool {
+func rewriteValueARM64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpNeqB(v *Value) bool {
+func rewriteValueARM64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM64_OpNeqPtr(v *Value) bool {
+func rewriteValueARM64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
return true
}
}
-func rewriteValueARM64_OpNilCheck(v *Value) bool {
+func rewriteValueARM64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueARM64_OpNot(v *Value) bool {
+func rewriteValueARM64_OpNot_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpOffPtr(v *Value) bool {
+func rewriteValueARM64_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVDaddr [off] ptr)
return true
}
}
-func rewriteValueARM64_OpOr16(v *Value) bool {
+func rewriteValueARM64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM64_OpOr32(v *Value) bool {
+func rewriteValueARM64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM64_OpOr64(v *Value) bool {
+func rewriteValueARM64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM64_OpOr8(v *Value) bool {
+func rewriteValueARM64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM64_OpOrB(v *Value) bool {
+func rewriteValueARM64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueARM64_OpRound32F(v *Value) bool {
+func rewriteValueARM64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpRound64F(v *Value) bool {
+func rewriteValueARM64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16x16(v *Value) bool {
+func rewriteValueARM64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16x32(v *Value) bool {
+func rewriteValueARM64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16x64(v *Value) bool {
+func rewriteValueARM64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh16x8(v *Value) bool {
+func rewriteValueARM64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32x16(v *Value) bool {
+func rewriteValueARM64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32x32(v *Value) bool {
+func rewriteValueARM64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32x64(v *Value) bool {
+func rewriteValueARM64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh32x8(v *Value) bool {
+func rewriteValueARM64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64x16(v *Value) bool {
+func rewriteValueARM64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64x32(v *Value) bool {
+func rewriteValueARM64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh64x64(v *Value) bool {
+func rewriteValueARM64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 x (MOVDconst [c]))
return true
}
}
-func rewriteValueARM64_OpRsh64x8(v *Value) bool {
+func rewriteValueARM64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8x16(v *Value) bool {
+func rewriteValueARM64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8x32(v *Value) bool {
+func rewriteValueARM64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8x64(v *Value) bool {
+func rewriteValueARM64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpRsh8x8(v *Value) bool {
+func rewriteValueARM64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueARM64_OpSignExt16to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueARM64_OpSignExt16to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueARM64_OpSignExt32to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
return true
}
}
-func rewriteValueARM64_OpSignExt8to16(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueARM64_OpSignExt8to32(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueARM64_OpSignExt8to64(v *Value) bool {
+func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueARM64_OpSlicemask(v *Value) bool {
+func rewriteValueARM64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueARM64_OpSqrt(v *Value) bool {
+func rewriteValueARM64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRTD x)
return true
}
}
-func rewriteValueARM64_OpStaticCall(v *Value) bool {
+func rewriteValueARM64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueARM64_OpStore(v *Value) bool {
+func rewriteValueARM64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
}
return false
}
-func rewriteValueARM64_OpSub16(v *Value) bool {
+func rewriteValueARM64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM64_OpSub32(v *Value) bool {
+func rewriteValueARM64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM64_OpSub32F(v *Value) bool {
+func rewriteValueARM64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
return true
}
}
-func rewriteValueARM64_OpSub64(v *Value) bool {
+func rewriteValueARM64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM64_OpSub64F(v *Value) bool {
+func rewriteValueARM64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUBD x y)
return true
}
}
-func rewriteValueARM64_OpSub8(v *Value) bool {
+func rewriteValueARM64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM64_OpSubPtr(v *Value) bool {
+func rewriteValueARM64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueARM64_OpTrunc16to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpTrunc32to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpTrunc32to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpTrunc64to16(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpTrunc64to32(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpTrunc64to8(v *Value) bool {
+func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueARM64_OpXor16(v *Value) bool {
+func rewriteValueARM64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM64_OpXor32(v *Value) bool {
+func rewriteValueARM64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM64_OpXor64(v *Value) bool {
+func rewriteValueARM64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM64_OpXor8(v *Value) bool {
+func rewriteValueARM64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueARM64_OpZero(v *Value) bool {
+func rewriteValueARM64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueARM64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [16] ptr mem)
// cond:
// result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem))
}
return false
}
-func rewriteValueARM64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueARM64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueARM64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWUreg x)
return true
}
}
-func rewriteValueARM64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueARM64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueARM64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueARM64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBUreg x)
func rewriteValueMIPS(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS_OpAdd16(v)
+ return rewriteValueMIPS_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueMIPS_OpAdd32(v)
+ return rewriteValueMIPS_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueMIPS_OpAdd32F(v)
+ return rewriteValueMIPS_OpAdd32F_0(v)
case OpAdd32withcarry:
- return rewriteValueMIPS_OpAdd32withcarry(v)
+ return rewriteValueMIPS_OpAdd32withcarry_0(v)
case OpAdd64F:
- return rewriteValueMIPS_OpAdd64F(v)
+ return rewriteValueMIPS_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueMIPS_OpAdd8(v)
+ return rewriteValueMIPS_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueMIPS_OpAddPtr(v)
+ return rewriteValueMIPS_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueMIPS_OpAddr(v)
+ return rewriteValueMIPS_OpAddr_0(v)
case OpAnd16:
- return rewriteValueMIPS_OpAnd16(v)
+ return rewriteValueMIPS_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueMIPS_OpAnd32(v)
+ return rewriteValueMIPS_OpAnd32_0(v)
case OpAnd8:
- return rewriteValueMIPS_OpAnd8(v)
+ return rewriteValueMIPS_OpAnd8_0(v)
case OpAndB:
- return rewriteValueMIPS_OpAndB(v)
+ return rewriteValueMIPS_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueMIPS_OpAtomicAdd32(v)
+ return rewriteValueMIPS_OpAtomicAdd32_0(v)
case OpAtomicAnd8:
- return rewriteValueMIPS_OpAtomicAnd8(v)
+ return rewriteValueMIPS_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueMIPS_OpAtomicCompareAndSwap32(v)
+ return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v)
case OpAtomicExchange32:
- return rewriteValueMIPS_OpAtomicExchange32(v)
+ return rewriteValueMIPS_OpAtomicExchange32_0(v)
case OpAtomicLoad32:
- return rewriteValueMIPS_OpAtomicLoad32(v)
+ return rewriteValueMIPS_OpAtomicLoad32_0(v)
case OpAtomicLoadPtr:
- return rewriteValueMIPS_OpAtomicLoadPtr(v)
+ return rewriteValueMIPS_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValueMIPS_OpAtomicOr8(v)
+ return rewriteValueMIPS_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValueMIPS_OpAtomicStore32(v)
+ return rewriteValueMIPS_OpAtomicStore32_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueMIPS_OpAtomicStorePtrNoWB(v)
+ return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v)
case OpAvg32u:
- return rewriteValueMIPS_OpAvg32u(v)
+ return rewriteValueMIPS_OpAvg32u_0(v)
case OpBitLen32:
- return rewriteValueMIPS_OpBitLen32(v)
+ return rewriteValueMIPS_OpBitLen32_0(v)
case OpClosureCall:
- return rewriteValueMIPS_OpClosureCall(v)
+ return rewriteValueMIPS_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueMIPS_OpCom16(v)
+ return rewriteValueMIPS_OpCom16_0(v)
case OpCom32:
- return rewriteValueMIPS_OpCom32(v)
+ return rewriteValueMIPS_OpCom32_0(v)
case OpCom8:
- return rewriteValueMIPS_OpCom8(v)
+ return rewriteValueMIPS_OpCom8_0(v)
case OpConst16:
- return rewriteValueMIPS_OpConst16(v)
+ return rewriteValueMIPS_OpConst16_0(v)
case OpConst32:
- return rewriteValueMIPS_OpConst32(v)
+ return rewriteValueMIPS_OpConst32_0(v)
case OpConst32F:
- return rewriteValueMIPS_OpConst32F(v)
+ return rewriteValueMIPS_OpConst32F_0(v)
case OpConst64F:
- return rewriteValueMIPS_OpConst64F(v)
+ return rewriteValueMIPS_OpConst64F_0(v)
case OpConst8:
- return rewriteValueMIPS_OpConst8(v)
+ return rewriteValueMIPS_OpConst8_0(v)
case OpConstBool:
- return rewriteValueMIPS_OpConstBool(v)
+ return rewriteValueMIPS_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueMIPS_OpConstNil(v)
+ return rewriteValueMIPS_OpConstNil_0(v)
case OpConvert:
- return rewriteValueMIPS_OpConvert(v)
+ return rewriteValueMIPS_OpConvert_0(v)
case OpCtz32:
- return rewriteValueMIPS_OpCtz32(v)
+ return rewriteValueMIPS_OpCtz32_0(v)
case OpCvt32Fto32:
- return rewriteValueMIPS_OpCvt32Fto32(v)
+ return rewriteValueMIPS_OpCvt32Fto32_0(v)
case OpCvt32Fto64F:
- return rewriteValueMIPS_OpCvt32Fto64F(v)
+ return rewriteValueMIPS_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueMIPS_OpCvt32to32F(v)
+ return rewriteValueMIPS_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueMIPS_OpCvt32to64F(v)
+ return rewriteValueMIPS_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueMIPS_OpCvt64Fto32(v)
+ return rewriteValueMIPS_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueMIPS_OpCvt64Fto32F(v)
+ return rewriteValueMIPS_OpCvt64Fto32F_0(v)
case OpDiv16:
- return rewriteValueMIPS_OpDiv16(v)
+ return rewriteValueMIPS_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueMIPS_OpDiv16u(v)
+ return rewriteValueMIPS_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueMIPS_OpDiv32(v)
+ return rewriteValueMIPS_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueMIPS_OpDiv32F(v)
+ return rewriteValueMIPS_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueMIPS_OpDiv32u(v)
+ return rewriteValueMIPS_OpDiv32u_0(v)
case OpDiv64F:
- return rewriteValueMIPS_OpDiv64F(v)
+ return rewriteValueMIPS_OpDiv64F_0(v)
case OpDiv8:
- return rewriteValueMIPS_OpDiv8(v)
+ return rewriteValueMIPS_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueMIPS_OpDiv8u(v)
+ return rewriteValueMIPS_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueMIPS_OpEq16(v)
+ return rewriteValueMIPS_OpEq16_0(v)
case OpEq32:
- return rewriteValueMIPS_OpEq32(v)
+ return rewriteValueMIPS_OpEq32_0(v)
case OpEq32F:
- return rewriteValueMIPS_OpEq32F(v)
+ return rewriteValueMIPS_OpEq32F_0(v)
case OpEq64F:
- return rewriteValueMIPS_OpEq64F(v)
+ return rewriteValueMIPS_OpEq64F_0(v)
case OpEq8:
- return rewriteValueMIPS_OpEq8(v)
+ return rewriteValueMIPS_OpEq8_0(v)
case OpEqB:
- return rewriteValueMIPS_OpEqB(v)
+ return rewriteValueMIPS_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueMIPS_OpEqPtr(v)
+ return rewriteValueMIPS_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueMIPS_OpGeq16(v)
+ return rewriteValueMIPS_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueMIPS_OpGeq16U(v)
+ return rewriteValueMIPS_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueMIPS_OpGeq32(v)
+ return rewriteValueMIPS_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueMIPS_OpGeq32F(v)
+ return rewriteValueMIPS_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueMIPS_OpGeq32U(v)
+ return rewriteValueMIPS_OpGeq32U_0(v)
case OpGeq64F:
- return rewriteValueMIPS_OpGeq64F(v)
+ return rewriteValueMIPS_OpGeq64F_0(v)
case OpGeq8:
- return rewriteValueMIPS_OpGeq8(v)
+ return rewriteValueMIPS_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueMIPS_OpGeq8U(v)
+ return rewriteValueMIPS_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueMIPS_OpGetClosurePtr(v)
+ return rewriteValueMIPS_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueMIPS_OpGreater16(v)
+ return rewriteValueMIPS_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueMIPS_OpGreater16U(v)
+ return rewriteValueMIPS_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueMIPS_OpGreater32(v)
+ return rewriteValueMIPS_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueMIPS_OpGreater32F(v)
+ return rewriteValueMIPS_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueMIPS_OpGreater32U(v)
+ return rewriteValueMIPS_OpGreater32U_0(v)
case OpGreater64F:
- return rewriteValueMIPS_OpGreater64F(v)
+ return rewriteValueMIPS_OpGreater64F_0(v)
case OpGreater8:
- return rewriteValueMIPS_OpGreater8(v)
+ return rewriteValueMIPS_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueMIPS_OpGreater8U(v)
+ return rewriteValueMIPS_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueMIPS_OpHmul32(v)
+ return rewriteValueMIPS_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueMIPS_OpHmul32u(v)
+ return rewriteValueMIPS_OpHmul32u_0(v)
case OpInterCall:
- return rewriteValueMIPS_OpInterCall(v)
+ return rewriteValueMIPS_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueMIPS_OpIsInBounds(v)
+ return rewriteValueMIPS_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueMIPS_OpIsNonNil(v)
+ return rewriteValueMIPS_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueMIPS_OpIsSliceInBounds(v)
+ return rewriteValueMIPS_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueMIPS_OpLeq16(v)
+ return rewriteValueMIPS_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueMIPS_OpLeq16U(v)
+ return rewriteValueMIPS_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueMIPS_OpLeq32(v)
+ return rewriteValueMIPS_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueMIPS_OpLeq32F(v)
+ return rewriteValueMIPS_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueMIPS_OpLeq32U(v)
+ return rewriteValueMIPS_OpLeq32U_0(v)
case OpLeq64F:
- return rewriteValueMIPS_OpLeq64F(v)
+ return rewriteValueMIPS_OpLeq64F_0(v)
case OpLeq8:
- return rewriteValueMIPS_OpLeq8(v)
+ return rewriteValueMIPS_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueMIPS_OpLeq8U(v)
+ return rewriteValueMIPS_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueMIPS_OpLess16(v)
+ return rewriteValueMIPS_OpLess16_0(v)
case OpLess16U:
- return rewriteValueMIPS_OpLess16U(v)
+ return rewriteValueMIPS_OpLess16U_0(v)
case OpLess32:
- return rewriteValueMIPS_OpLess32(v)
+ return rewriteValueMIPS_OpLess32_0(v)
case OpLess32F:
- return rewriteValueMIPS_OpLess32F(v)
+ return rewriteValueMIPS_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueMIPS_OpLess32U(v)
+ return rewriteValueMIPS_OpLess32U_0(v)
case OpLess64F:
- return rewriteValueMIPS_OpLess64F(v)
+ return rewriteValueMIPS_OpLess64F_0(v)
case OpLess8:
- return rewriteValueMIPS_OpLess8(v)
+ return rewriteValueMIPS_OpLess8_0(v)
case OpLess8U:
- return rewriteValueMIPS_OpLess8U(v)
+ return rewriteValueMIPS_OpLess8U_0(v)
case OpLoad:
- return rewriteValueMIPS_OpLoad(v)
+ return rewriteValueMIPS_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueMIPS_OpLsh16x16(v)
+ return rewriteValueMIPS_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueMIPS_OpLsh16x32(v)
+ return rewriteValueMIPS_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueMIPS_OpLsh16x64(v)
+ return rewriteValueMIPS_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueMIPS_OpLsh16x8(v)
+ return rewriteValueMIPS_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueMIPS_OpLsh32x16(v)
+ return rewriteValueMIPS_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueMIPS_OpLsh32x32(v)
+ return rewriteValueMIPS_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueMIPS_OpLsh32x64(v)
+ return rewriteValueMIPS_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueMIPS_OpLsh32x8(v)
+ return rewriteValueMIPS_OpLsh32x8_0(v)
case OpLsh8x16:
- return rewriteValueMIPS_OpLsh8x16(v)
+ return rewriteValueMIPS_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueMIPS_OpLsh8x32(v)
+ return rewriteValueMIPS_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueMIPS_OpLsh8x64(v)
+ return rewriteValueMIPS_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueMIPS_OpLsh8x8(v)
+ return rewriteValueMIPS_OpLsh8x8_0(v)
case OpMIPSADD:
- return rewriteValueMIPS_OpMIPSADD(v)
+ return rewriteValueMIPS_OpMIPSADD_0(v)
case OpMIPSADDconst:
- return rewriteValueMIPS_OpMIPSADDconst(v)
+ return rewriteValueMIPS_OpMIPSADDconst_0(v)
case OpMIPSAND:
- return rewriteValueMIPS_OpMIPSAND(v)
+ return rewriteValueMIPS_OpMIPSAND_0(v)
case OpMIPSANDconst:
- return rewriteValueMIPS_OpMIPSANDconst(v)
+ return rewriteValueMIPS_OpMIPSANDconst_0(v)
case OpMIPSCMOVZ:
- return rewriteValueMIPS_OpMIPSCMOVZ(v)
+ return rewriteValueMIPS_OpMIPSCMOVZ_0(v)
case OpMIPSCMOVZzero:
- return rewriteValueMIPS_OpMIPSCMOVZzero(v)
+ return rewriteValueMIPS_OpMIPSCMOVZzero_0(v)
case OpMIPSLoweredAtomicAdd:
- return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v)
+ return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v)
case OpMIPSLoweredAtomicStore:
- return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v)
+ return rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v)
case OpMIPSMOVBUload:
- return rewriteValueMIPS_OpMIPSMOVBUload(v)
+ return rewriteValueMIPS_OpMIPSMOVBUload_0(v)
case OpMIPSMOVBUreg:
- return rewriteValueMIPS_OpMIPSMOVBUreg(v)
+ return rewriteValueMIPS_OpMIPSMOVBUreg_0(v)
case OpMIPSMOVBload:
- return rewriteValueMIPS_OpMIPSMOVBload(v)
+ return rewriteValueMIPS_OpMIPSMOVBload_0(v)
case OpMIPSMOVBreg:
- return rewriteValueMIPS_OpMIPSMOVBreg(v)
+ return rewriteValueMIPS_OpMIPSMOVBreg_0(v)
case OpMIPSMOVBstore:
- return rewriteValueMIPS_OpMIPSMOVBstore(v)
+ return rewriteValueMIPS_OpMIPSMOVBstore_0(v)
case OpMIPSMOVBstorezero:
- return rewriteValueMIPS_OpMIPSMOVBstorezero(v)
+ return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v)
case OpMIPSMOVDload:
- return rewriteValueMIPS_OpMIPSMOVDload(v)
+ return rewriteValueMIPS_OpMIPSMOVDload_0(v)
case OpMIPSMOVDstore:
- return rewriteValueMIPS_OpMIPSMOVDstore(v)
+ return rewriteValueMIPS_OpMIPSMOVDstore_0(v)
case OpMIPSMOVFload:
- return rewriteValueMIPS_OpMIPSMOVFload(v)
+ return rewriteValueMIPS_OpMIPSMOVFload_0(v)
case OpMIPSMOVFstore:
- return rewriteValueMIPS_OpMIPSMOVFstore(v)
+ return rewriteValueMIPS_OpMIPSMOVFstore_0(v)
case OpMIPSMOVHUload:
- return rewriteValueMIPS_OpMIPSMOVHUload(v)
+ return rewriteValueMIPS_OpMIPSMOVHUload_0(v)
case OpMIPSMOVHUreg:
- return rewriteValueMIPS_OpMIPSMOVHUreg(v)
+ return rewriteValueMIPS_OpMIPSMOVHUreg_0(v)
case OpMIPSMOVHload:
- return rewriteValueMIPS_OpMIPSMOVHload(v)
+ return rewriteValueMIPS_OpMIPSMOVHload_0(v)
case OpMIPSMOVHreg:
- return rewriteValueMIPS_OpMIPSMOVHreg(v)
+ return rewriteValueMIPS_OpMIPSMOVHreg_0(v)
case OpMIPSMOVHstore:
- return rewriteValueMIPS_OpMIPSMOVHstore(v)
+ return rewriteValueMIPS_OpMIPSMOVHstore_0(v)
case OpMIPSMOVHstorezero:
- return rewriteValueMIPS_OpMIPSMOVHstorezero(v)
+ return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v)
case OpMIPSMOVWload:
- return rewriteValueMIPS_OpMIPSMOVWload(v)
+ return rewriteValueMIPS_OpMIPSMOVWload_0(v)
case OpMIPSMOVWreg:
- return rewriteValueMIPS_OpMIPSMOVWreg(v)
+ return rewriteValueMIPS_OpMIPSMOVWreg_0(v)
case OpMIPSMOVWstore:
- return rewriteValueMIPS_OpMIPSMOVWstore(v)
+ return rewriteValueMIPS_OpMIPSMOVWstore_0(v)
case OpMIPSMOVWstorezero:
- return rewriteValueMIPS_OpMIPSMOVWstorezero(v)
+ return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v)
case OpMIPSMUL:
- return rewriteValueMIPS_OpMIPSMUL(v)
+ return rewriteValueMIPS_OpMIPSMUL_0(v)
case OpMIPSNEG:
- return rewriteValueMIPS_OpMIPSNEG(v)
+ return rewriteValueMIPS_OpMIPSNEG_0(v)
case OpMIPSNOR:
- return rewriteValueMIPS_OpMIPSNOR(v)
+ return rewriteValueMIPS_OpMIPSNOR_0(v)
case OpMIPSNORconst:
- return rewriteValueMIPS_OpMIPSNORconst(v)
+ return rewriteValueMIPS_OpMIPSNORconst_0(v)
case OpMIPSOR:
- return rewriteValueMIPS_OpMIPSOR(v)
+ return rewriteValueMIPS_OpMIPSOR_0(v)
case OpMIPSORconst:
- return rewriteValueMIPS_OpMIPSORconst(v)
+ return rewriteValueMIPS_OpMIPSORconst_0(v)
case OpMIPSSGT:
- return rewriteValueMIPS_OpMIPSSGT(v)
+ return rewriteValueMIPS_OpMIPSSGT_0(v)
case OpMIPSSGTU:
- return rewriteValueMIPS_OpMIPSSGTU(v)
+ return rewriteValueMIPS_OpMIPSSGTU_0(v)
case OpMIPSSGTUconst:
- return rewriteValueMIPS_OpMIPSSGTUconst(v)
+ return rewriteValueMIPS_OpMIPSSGTUconst_0(v)
case OpMIPSSGTUzero:
- return rewriteValueMIPS_OpMIPSSGTUzero(v)
+ return rewriteValueMIPS_OpMIPSSGTUzero_0(v)
case OpMIPSSGTconst:
- return rewriteValueMIPS_OpMIPSSGTconst(v)
+ return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v)
case OpMIPSSGTzero:
- return rewriteValueMIPS_OpMIPSSGTzero(v)
+ return rewriteValueMIPS_OpMIPSSGTzero_0(v)
case OpMIPSSLL:
- return rewriteValueMIPS_OpMIPSSLL(v)
+ return rewriteValueMIPS_OpMIPSSLL_0(v)
case OpMIPSSLLconst:
- return rewriteValueMIPS_OpMIPSSLLconst(v)
+ return rewriteValueMIPS_OpMIPSSLLconst_0(v)
case OpMIPSSRA:
- return rewriteValueMIPS_OpMIPSSRA(v)
+ return rewriteValueMIPS_OpMIPSSRA_0(v)
case OpMIPSSRAconst:
- return rewriteValueMIPS_OpMIPSSRAconst(v)
+ return rewriteValueMIPS_OpMIPSSRAconst_0(v)
case OpMIPSSRL:
- return rewriteValueMIPS_OpMIPSSRL(v)
+ return rewriteValueMIPS_OpMIPSSRL_0(v)
case OpMIPSSRLconst:
- return rewriteValueMIPS_OpMIPSSRLconst(v)
+ return rewriteValueMIPS_OpMIPSSRLconst_0(v)
case OpMIPSSUB:
- return rewriteValueMIPS_OpMIPSSUB(v)
+ return rewriteValueMIPS_OpMIPSSUB_0(v)
case OpMIPSSUBconst:
- return rewriteValueMIPS_OpMIPSSUBconst(v)
+ return rewriteValueMIPS_OpMIPSSUBconst_0(v)
case OpMIPSXOR:
- return rewriteValueMIPS_OpMIPSXOR(v)
+ return rewriteValueMIPS_OpMIPSXOR_0(v)
case OpMIPSXORconst:
- return rewriteValueMIPS_OpMIPSXORconst(v)
+ return rewriteValueMIPS_OpMIPSXORconst_0(v)
case OpMod16:
- return rewriteValueMIPS_OpMod16(v)
+ return rewriteValueMIPS_OpMod16_0(v)
case OpMod16u:
- return rewriteValueMIPS_OpMod16u(v)
+ return rewriteValueMIPS_OpMod16u_0(v)
case OpMod32:
- return rewriteValueMIPS_OpMod32(v)
+ return rewriteValueMIPS_OpMod32_0(v)
case OpMod32u:
- return rewriteValueMIPS_OpMod32u(v)
+ return rewriteValueMIPS_OpMod32u_0(v)
case OpMod8:
- return rewriteValueMIPS_OpMod8(v)
+ return rewriteValueMIPS_OpMod8_0(v)
case OpMod8u:
- return rewriteValueMIPS_OpMod8u(v)
+ return rewriteValueMIPS_OpMod8u_0(v)
case OpMove:
- return rewriteValueMIPS_OpMove(v)
+ return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v)
case OpMul16:
- return rewriteValueMIPS_OpMul16(v)
+ return rewriteValueMIPS_OpMul16_0(v)
case OpMul32:
- return rewriteValueMIPS_OpMul32(v)
+ return rewriteValueMIPS_OpMul32_0(v)
case OpMul32F:
- return rewriteValueMIPS_OpMul32F(v)
+ return rewriteValueMIPS_OpMul32F_0(v)
case OpMul32uhilo:
- return rewriteValueMIPS_OpMul32uhilo(v)
+ return rewriteValueMIPS_OpMul32uhilo_0(v)
case OpMul64F:
- return rewriteValueMIPS_OpMul64F(v)
+ return rewriteValueMIPS_OpMul64F_0(v)
case OpMul8:
- return rewriteValueMIPS_OpMul8(v)
+ return rewriteValueMIPS_OpMul8_0(v)
case OpNeg16:
- return rewriteValueMIPS_OpNeg16(v)
+ return rewriteValueMIPS_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueMIPS_OpNeg32(v)
+ return rewriteValueMIPS_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueMIPS_OpNeg32F(v)
+ return rewriteValueMIPS_OpNeg32F_0(v)
case OpNeg64F:
- return rewriteValueMIPS_OpNeg64F(v)
+ return rewriteValueMIPS_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueMIPS_OpNeg8(v)
+ return rewriteValueMIPS_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueMIPS_OpNeq16(v)
+ return rewriteValueMIPS_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueMIPS_OpNeq32(v)
+ return rewriteValueMIPS_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueMIPS_OpNeq32F(v)
+ return rewriteValueMIPS_OpNeq32F_0(v)
case OpNeq64F:
- return rewriteValueMIPS_OpNeq64F(v)
+ return rewriteValueMIPS_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueMIPS_OpNeq8(v)
+ return rewriteValueMIPS_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueMIPS_OpNeqB(v)
+ return rewriteValueMIPS_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueMIPS_OpNeqPtr(v)
+ return rewriteValueMIPS_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueMIPS_OpNilCheck(v)
+ return rewriteValueMIPS_OpNilCheck_0(v)
case OpNot:
- return rewriteValueMIPS_OpNot(v)
+ return rewriteValueMIPS_OpNot_0(v)
case OpOffPtr:
- return rewriteValueMIPS_OpOffPtr(v)
+ return rewriteValueMIPS_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueMIPS_OpOr16(v)
+ return rewriteValueMIPS_OpOr16_0(v)
case OpOr32:
- return rewriteValueMIPS_OpOr32(v)
+ return rewriteValueMIPS_OpOr32_0(v)
case OpOr8:
- return rewriteValueMIPS_OpOr8(v)
+ return rewriteValueMIPS_OpOr8_0(v)
case OpOrB:
- return rewriteValueMIPS_OpOrB(v)
+ return rewriteValueMIPS_OpOrB_0(v)
case OpRound32F:
- return rewriteValueMIPS_OpRound32F(v)
+ return rewriteValueMIPS_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueMIPS_OpRound64F(v)
+ return rewriteValueMIPS_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueMIPS_OpRsh16Ux16(v)
+ return rewriteValueMIPS_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueMIPS_OpRsh16Ux32(v)
+ return rewriteValueMIPS_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueMIPS_OpRsh16Ux64(v)
+ return rewriteValueMIPS_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueMIPS_OpRsh16Ux8(v)
+ return rewriteValueMIPS_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueMIPS_OpRsh16x16(v)
+ return rewriteValueMIPS_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueMIPS_OpRsh16x32(v)
+ return rewriteValueMIPS_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueMIPS_OpRsh16x64(v)
+ return rewriteValueMIPS_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueMIPS_OpRsh16x8(v)
+ return rewriteValueMIPS_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueMIPS_OpRsh32Ux16(v)
+ return rewriteValueMIPS_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueMIPS_OpRsh32Ux32(v)
+ return rewriteValueMIPS_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueMIPS_OpRsh32Ux64(v)
+ return rewriteValueMIPS_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueMIPS_OpRsh32Ux8(v)
+ return rewriteValueMIPS_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueMIPS_OpRsh32x16(v)
+ return rewriteValueMIPS_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueMIPS_OpRsh32x32(v)
+ return rewriteValueMIPS_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueMIPS_OpRsh32x64(v)
+ return rewriteValueMIPS_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueMIPS_OpRsh32x8(v)
+ return rewriteValueMIPS_OpRsh32x8_0(v)
case OpRsh8Ux16:
- return rewriteValueMIPS_OpRsh8Ux16(v)
+ return rewriteValueMIPS_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueMIPS_OpRsh8Ux32(v)
+ return rewriteValueMIPS_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueMIPS_OpRsh8Ux64(v)
+ return rewriteValueMIPS_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueMIPS_OpRsh8Ux8(v)
+ return rewriteValueMIPS_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueMIPS_OpRsh8x16(v)
+ return rewriteValueMIPS_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueMIPS_OpRsh8x32(v)
+ return rewriteValueMIPS_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueMIPS_OpRsh8x64(v)
+ return rewriteValueMIPS_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueMIPS_OpRsh8x8(v)
+ return rewriteValueMIPS_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueMIPS_OpSelect0(v)
+ return rewriteValueMIPS_OpSelect0_0(v) || rewriteValueMIPS_OpSelect0_10(v)
case OpSelect1:
- return rewriteValueMIPS_OpSelect1(v)
+ return rewriteValueMIPS_OpSelect1_0(v) || rewriteValueMIPS_OpSelect1_10(v)
case OpSignExt16to32:
- return rewriteValueMIPS_OpSignExt16to32(v)
+ return rewriteValueMIPS_OpSignExt16to32_0(v)
case OpSignExt8to16:
- return rewriteValueMIPS_OpSignExt8to16(v)
+ return rewriteValueMIPS_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueMIPS_OpSignExt8to32(v)
+ return rewriteValueMIPS_OpSignExt8to32_0(v)
case OpSignmask:
- return rewriteValueMIPS_OpSignmask(v)
+ return rewriteValueMIPS_OpSignmask_0(v)
case OpSlicemask:
- return rewriteValueMIPS_OpSlicemask(v)
+ return rewriteValueMIPS_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueMIPS_OpSqrt(v)
+ return rewriteValueMIPS_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueMIPS_OpStaticCall(v)
+ return rewriteValueMIPS_OpStaticCall_0(v)
case OpStore:
- return rewriteValueMIPS_OpStore(v)
+ return rewriteValueMIPS_OpStore_0(v)
case OpSub16:
- return rewriteValueMIPS_OpSub16(v)
+ return rewriteValueMIPS_OpSub16_0(v)
case OpSub32:
- return rewriteValueMIPS_OpSub32(v)
+ return rewriteValueMIPS_OpSub32_0(v)
case OpSub32F:
- return rewriteValueMIPS_OpSub32F(v)
+ return rewriteValueMIPS_OpSub32F_0(v)
case OpSub32withcarry:
- return rewriteValueMIPS_OpSub32withcarry(v)
+ return rewriteValueMIPS_OpSub32withcarry_0(v)
case OpSub64F:
- return rewriteValueMIPS_OpSub64F(v)
+ return rewriteValueMIPS_OpSub64F_0(v)
case OpSub8:
- return rewriteValueMIPS_OpSub8(v)
+ return rewriteValueMIPS_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueMIPS_OpSubPtr(v)
+ return rewriteValueMIPS_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueMIPS_OpTrunc16to8(v)
+ return rewriteValueMIPS_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueMIPS_OpTrunc32to16(v)
+ return rewriteValueMIPS_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueMIPS_OpTrunc32to8(v)
+ return rewriteValueMIPS_OpTrunc32to8_0(v)
case OpXor16:
- return rewriteValueMIPS_OpXor16(v)
+ return rewriteValueMIPS_OpXor16_0(v)
case OpXor32:
- return rewriteValueMIPS_OpXor32(v)
+ return rewriteValueMIPS_OpXor32_0(v)
case OpXor8:
- return rewriteValueMIPS_OpXor8(v)
+ return rewriteValueMIPS_OpXor8_0(v)
case OpZero:
- return rewriteValueMIPS_OpZero(v)
+ return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueMIPS_OpZeroExt16to32(v)
+ return rewriteValueMIPS_OpZeroExt16to32_0(v)
case OpZeroExt8to16:
- return rewriteValueMIPS_OpZeroExt8to16(v)
+ return rewriteValueMIPS_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueMIPS_OpZeroExt8to32(v)
+ return rewriteValueMIPS_OpZeroExt8to32_0(v)
case OpZeromask:
- return rewriteValueMIPS_OpZeromask(v)
+ return rewriteValueMIPS_OpZeromask_0(v)
}
return false
}
-func rewriteValueMIPS_OpAdd16(v *Value) bool {
+func rewriteValueMIPS_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueMIPS_OpAdd32(v *Value) bool {
+func rewriteValueMIPS_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueMIPS_OpAdd32F(v *Value) bool {
+func rewriteValueMIPS_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
return true
}
}
-func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool {
+func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add32withcarry <t> x y c)
return true
}
}
-func rewriteValueMIPS_OpAdd64F(v *Value) bool {
+func rewriteValueMIPS_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
return true
}
}
-func rewriteValueMIPS_OpAdd8(v *Value) bool {
+func rewriteValueMIPS_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueMIPS_OpAddPtr(v *Value) bool {
+func rewriteValueMIPS_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueMIPS_OpAddr(v *Value) bool {
+func rewriteValueMIPS_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVWaddr {sym} base)
return true
}
}
-func rewriteValueMIPS_OpAnd16(v *Value) bool {
+func rewriteValueMIPS_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS_OpAnd32(v *Value) bool {
+func rewriteValueMIPS_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS_OpAnd8(v *Value) bool {
+func rewriteValueMIPS_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS_OpAndB(v *Value) bool {
+func rewriteValueMIPS_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd ptr val mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool {
+func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas ptr old new_ mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange ptr val mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LoweredAtomicLoad ptr mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LoweredAtomicLoad ptr mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicOr8(v *Value) bool {
+func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValueMIPS_OpAtomicStore32(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (LoweredAtomicStore ptr val mem)
return true
}
}
-func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (LoweredAtomicStore ptr val mem)
return true
}
}
-func rewriteValueMIPS_OpAvg32u(v *Value) bool {
+func rewriteValueMIPS_OpAvg32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg32u <t> x y)
return true
}
}
-func rewriteValueMIPS_OpBitLen32(v *Value) bool {
+func rewriteValueMIPS_OpBitLen32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpClosureCall(v *Value) bool {
+func rewriteValueMIPS_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueMIPS_OpCom16(v *Value) bool {
+func rewriteValueMIPS_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NORconst [0] x)
return true
}
}
-func rewriteValueMIPS_OpCom32(v *Value) bool {
+func rewriteValueMIPS_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NORconst [0] x)
return true
}
}
-func rewriteValueMIPS_OpCom8(v *Value) bool {
+func rewriteValueMIPS_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NORconst [0] x)
return true
}
}
-func rewriteValueMIPS_OpConst16(v *Value) bool {
+func rewriteValueMIPS_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueMIPS_OpConst32(v *Value) bool {
+func rewriteValueMIPS_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueMIPS_OpConst32F(v *Value) bool {
+func rewriteValueMIPS_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
return true
}
}
-func rewriteValueMIPS_OpConst64F(v *Value) bool {
+func rewriteValueMIPS_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueMIPS_OpConst8(v *Value) bool {
+func rewriteValueMIPS_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVWconst [val])
return true
}
}
-func rewriteValueMIPS_OpConstBool(v *Value) bool {
+func rewriteValueMIPS_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVWconst [b])
return true
}
}
-func rewriteValueMIPS_OpConstNil(v *Value) bool {
+func rewriteValueMIPS_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVWconst [0])
return true
}
}
-func rewriteValueMIPS_OpConvert(v *Value) bool {
+func rewriteValueMIPS_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVWconvert x mem)
return true
}
}
-func rewriteValueMIPS_OpCtz32(v *Value) bool {
+func rewriteValueMIPS_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (TRUNCFW x)
return true
}
}
-func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
return true
}
}
-func rewriteValueMIPS_OpCvt32to32F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
return true
}
}
-func rewriteValueMIPS_OpCvt32to64F(v *Value) bool {
+func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
return true
}
}
-func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (TRUNCDW x)
return true
}
}
-func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
return true
}
}
-func rewriteValueMIPS_OpDiv16(v *Value) bool {
+func rewriteValueMIPS_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpDiv16u(v *Value) bool {
+func rewriteValueMIPS_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpDiv32(v *Value) bool {
+func rewriteValueMIPS_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpDiv32F(v *Value) bool {
+func rewriteValueMIPS_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
return true
}
}
-func rewriteValueMIPS_OpDiv32u(v *Value) bool {
+func rewriteValueMIPS_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpDiv64F(v *Value) bool {
+func rewriteValueMIPS_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
return true
}
}
-func rewriteValueMIPS_OpDiv8(v *Value) bool {
+func rewriteValueMIPS_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpDiv8u(v *Value) bool {
+func rewriteValueMIPS_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpEq16(v *Value) bool {
+func rewriteValueMIPS_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpEq32(v *Value) bool {
+func rewriteValueMIPS_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpEq32F(v *Value) bool {
+func rewriteValueMIPS_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValueMIPS_OpEq64F(v *Value) bool {
+func rewriteValueMIPS_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValueMIPS_OpEq8(v *Value) bool {
+func rewriteValueMIPS_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpEqB(v *Value) bool {
+func rewriteValueMIPS_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpEqPtr(v *Value) bool {
+func rewriteValueMIPS_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq16(v *Value) bool {
+func rewriteValueMIPS_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq16U(v *Value) bool {
+func rewriteValueMIPS_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq32(v *Value) bool {
+func rewriteValueMIPS_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq32F(v *Value) bool {
+func rewriteValueMIPS_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValueMIPS_OpGeq32U(v *Value) bool {
+func rewriteValueMIPS_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq64F(v *Value) bool {
+func rewriteValueMIPS_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValueMIPS_OpGeq8(v *Value) bool {
+func rewriteValueMIPS_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGeq8U(v *Value) bool {
+func rewriteValueMIPS_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueMIPS_OpGreater16(v *Value) bool {
+func rewriteValueMIPS_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGreater16U(v *Value) bool {
+func rewriteValueMIPS_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGreater32(v *Value) bool {
+func rewriteValueMIPS_OpGreater32_0(v *Value) bool {
// match: (Greater32 x y)
// cond:
// result: (SGT x y)
return true
}
}
-func rewriteValueMIPS_OpGreater32F(v *Value) bool {
+func rewriteValueMIPS_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValueMIPS_OpGreater32U(v *Value) bool {
+func rewriteValueMIPS_OpGreater32U_0(v *Value) bool {
// match: (Greater32U x y)
// cond:
// result: (SGTU x y)
return true
}
}
-func rewriteValueMIPS_OpGreater64F(v *Value) bool {
+func rewriteValueMIPS_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValueMIPS_OpGreater8(v *Value) bool {
+func rewriteValueMIPS_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpGreater8U(v *Value) bool {
+func rewriteValueMIPS_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpHmul32(v *Value) bool {
+func rewriteValueMIPS_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpHmul32u(v *Value) bool {
+func rewriteValueMIPS_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpInterCall(v *Value) bool {
+func rewriteValueMIPS_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueMIPS_OpIsInBounds(v *Value) bool {
+func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds idx len)
// cond:
// result: (SGTU len idx)
return true
}
}
-func rewriteValueMIPS_OpIsNonNil(v *Value) bool {
+func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq16(v *Value) bool {
+func rewriteValueMIPS_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq16U(v *Value) bool {
+func rewriteValueMIPS_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq32(v *Value) bool {
+func rewriteValueMIPS_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq32F(v *Value) bool {
+func rewriteValueMIPS_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValueMIPS_OpLeq32U(v *Value) bool {
+func rewriteValueMIPS_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq64F(v *Value) bool {
+func rewriteValueMIPS_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValueMIPS_OpLeq8(v *Value) bool {
+func rewriteValueMIPS_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLeq8U(v *Value) bool {
+func rewriteValueMIPS_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLess16(v *Value) bool {
+func rewriteValueMIPS_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLess16U(v *Value) bool {
+func rewriteValueMIPS_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLess32(v *Value) bool {
+func rewriteValueMIPS_OpLess32_0(v *Value) bool {
// match: (Less32 x y)
// cond:
// result: (SGT y x)
return true
}
}
-func rewriteValueMIPS_OpLess32F(v *Value) bool {
+func rewriteValueMIPS_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValueMIPS_OpLess32U(v *Value) bool {
+func rewriteValueMIPS_OpLess32U_0(v *Value) bool {
// match: (Less32U x y)
// cond:
// result: (SGTU y x)
return true
}
}
-func rewriteValueMIPS_OpLess64F(v *Value) bool {
+func rewriteValueMIPS_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValueMIPS_OpLess8(v *Value) bool {
+func rewriteValueMIPS_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLess8U(v *Value) bool {
+func rewriteValueMIPS_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLoad(v *Value) bool {
+func rewriteValueMIPS_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
}
return false
}
-func rewriteValueMIPS_OpLsh16x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh16x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh16x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool {
// match: (Lsh16x64 x (Const64 [c]))
// cond: uint32(c) < 16
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueMIPS_OpLsh16x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh32x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh32x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh32x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool {
// match: (Lsh32x64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueMIPS_OpLsh32x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh8x16(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh8x32(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpLsh8x64(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool {
// match: (Lsh8x64 x (Const64 [c]))
// cond: uint32(c) < 8
// result: (SLLconst x [c])
}
return false
}
-func rewriteValueMIPS_OpLsh8x8(v *Value) bool {
+func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMIPSADD(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool {
// match: (ADD x (MOVWconst [c]))
// cond:
// result: (ADDconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool {
// match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr))
// cond:
// result: (MOVWaddr [off1+off2] {sym} ptr)
}
return false
}
-func rewriteValueMIPS_OpMIPSAND(v *Value) bool {
+func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool {
b := v.Block
_ = b
// match: (AND x (MOVWconst [c]))
}
return false
}
-func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMOVZ _ b (MOVWconst [0]))
}
return false
}
-func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool {
// match: (CMOVZzero _ (MOVWconst [0]))
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool {
// match: (LoweredAtomicAdd ptr (MOVWconst [c]) mem)
// cond: is16Bit(c)
// result: (LoweredAtomicAddconst [c] ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v *Value) bool {
// match: (LoweredAtomicStore ptr (MOVWconst [0]) mem)
// cond:
// result: (LoweredAtomicStorezero ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBUreg x:(MOVBUload _ _))
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBreg x:(MOVBload _ _))
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVFload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHUreg x:(MOVBUload _ _))
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHreg x:(MOVBload _ _))
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool {
// match: (MOVWreg x)
// cond: x.Uses == 1
// result: (MOVWnop x)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} x:(ADDconst [off2] ptr) val mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem)
// cond: (is16Bit(off1+off2) || x.Uses == 1)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS_OpMIPSMUL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool {
// match: (MUL (MOVWconst [0]) _)
// cond:
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueMIPS_OpMIPSNEG(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool {
// match: (NEG (MOVWconst [c]))
// cond:
// result: (MOVWconst [int64(int32(-c))])
}
return false
}
-func rewriteValueMIPS_OpMIPSNOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool {
// match: (NOR x (MOVWconst [c]))
// cond:
// result: (NORconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool {
// match: (NORconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [^(c|d)])
}
return false
}
-func rewriteValueMIPS_OpMIPSOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool {
b := v.Block
_ = b
// match: (OR x (MOVWconst [c]))
}
return false
}
-func rewriteValueMIPS_OpMIPSORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS_OpMIPSSGT(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool {
// match: (SGT (MOVWconst [c]) x)
// cond:
// result: (SGTconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool {
// match: (SGTU (MOVWconst [c]) x)
// cond:
// result: (SGTUconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool {
// match: (SGTUconst [c] (MOVWconst [d]))
// cond: uint32(c)>uint32(d)
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool {
// match: (SGTUzero (MOVWconst [d]))
// cond: uint32(d) != 0
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool {
// match: (SGTconst [c] (MOVWconst [d]))
// cond: int32(c) > int32(d)
// result: (MOVWconst [1])
v.AuxInt = 0
return true
}
+ return false
+}
+func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool {
// match: (SGTconst [c] (ANDconst [m] _))
// cond: 0 <= int32(m) && int32(m) < int32(c)
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool {
// match: (SGTzero (MOVWconst [d]))
// cond: int32(d) > 0
// result: (MOVWconst [1])
}
return false
}
-func rewriteValueMIPS_OpMIPSSLL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool {
// match: (SLL _ (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool {
// match: (SLLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(uint32(d)<<uint32(c)))])
}
return false
}
-func rewriteValueMIPS_OpMIPSSRA(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRA_0(v *Value) bool {
// match: (SRA x (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (SRAconst x [31])
}
return false
}
-func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool {
// match: (SRAconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(int32(d)>>uint32(c))])
}
return false
}
-func rewriteValueMIPS_OpMIPSSRL(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool {
// match: (SRL _ (MOVWconst [c]))
// cond: uint32(c)>=32
// result: (MOVWconst [0])
}
return false
}
-func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool {
// match: (SRLconst [c] (MOVWconst [d]))
// cond:
// result: (MOVWconst [int64(uint32(d)>>uint32(c))])
}
return false
}
-func rewriteValueMIPS_OpMIPSSUB(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool {
// match: (SUB x (MOVWconst [c]))
// cond:
// result: (SUBconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS_OpMIPSXOR(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool {
// match: (XOR x (MOVWconst [c]))
// cond:
// result: (XORconst [c] x)
}
return false
}
-func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool {
+func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS_OpMod16(v *Value) bool {
+func rewriteValueMIPS_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMod16u(v *Value) bool {
+func rewriteValueMIPS_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMod32(v *Value) bool {
+func rewriteValueMIPS_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMod32u(v *Value) bool {
+func rewriteValueMIPS_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMod8(v *Value) bool {
+func rewriteValueMIPS_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMod8u(v *Value) bool {
+func rewriteValueMIPS_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpMove(v *Value) bool {
+func rewriteValueMIPS_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [6] {t} dst src mem)
// cond: t.(Type).Alignment()%2 == 0
// result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem)))
}
return false
}
-func rewriteValueMIPS_OpMul16(v *Value) bool {
+func rewriteValueMIPS_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueMIPS_OpMul32(v *Value) bool {
+func rewriteValueMIPS_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueMIPS_OpMul32F(v *Value) bool {
+func rewriteValueMIPS_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
return true
}
}
-func rewriteValueMIPS_OpMul32uhilo(v *Value) bool {
+func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool {
// match: (Mul32uhilo x y)
// cond:
// result: (MULTU x y)
return true
}
}
-func rewriteValueMIPS_OpMul64F(v *Value) bool {
+func rewriteValueMIPS_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
return true
}
}
-func rewriteValueMIPS_OpMul8(v *Value) bool {
+func rewriteValueMIPS_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MUL x y)
return true
}
}
-func rewriteValueMIPS_OpNeg16(v *Value) bool {
+func rewriteValueMIPS_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueMIPS_OpNeg32(v *Value) bool {
+func rewriteValueMIPS_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueMIPS_OpNeg32F(v *Value) bool {
+func rewriteValueMIPS_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
return true
}
}
-func rewriteValueMIPS_OpNeg64F(v *Value) bool {
+func rewriteValueMIPS_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
return true
}
}
-func rewriteValueMIPS_OpNeg8(v *Value) bool {
+func rewriteValueMIPS_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueMIPS_OpNeq16(v *Value) bool {
+func rewriteValueMIPS_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpNeq32(v *Value) bool {
+func rewriteValueMIPS_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpNeq32F(v *Value) bool {
+func rewriteValueMIPS_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValueMIPS_OpNeq64F(v *Value) bool {
+func rewriteValueMIPS_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValueMIPS_OpNeq8(v *Value) bool {
+func rewriteValueMIPS_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpNeqB(v *Value) bool {
+func rewriteValueMIPS_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS_OpNeqPtr(v *Value) bool {
+func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpNilCheck(v *Value) bool {
+func rewriteValueMIPS_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueMIPS_OpNot(v *Value) bool {
+func rewriteValueMIPS_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
return true
}
}
-func rewriteValueMIPS_OpOffPtr(v *Value) bool {
+func rewriteValueMIPS_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVWaddr [off] ptr)
return true
}
}
-func rewriteValueMIPS_OpOr16(v *Value) bool {
+func rewriteValueMIPS_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS_OpOr32(v *Value) bool {
+func rewriteValueMIPS_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS_OpOr8(v *Value) bool {
+func rewriteValueMIPS_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS_OpOrB(v *Value) bool {
+func rewriteValueMIPS_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS_OpRound32F(v *Value) bool {
+func rewriteValueMIPS_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS_OpRound64F(v *Value) bool {
+func rewriteValueMIPS_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh16x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh16x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh16x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueMIPS_OpRsh16x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool {
// match: (Rsh32Ux64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRLconst x [c])
}
return false
}
-func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh32x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool {
// match: (Rsh32x64 x (Const64 [c]))
// cond: uint32(c) < 32
// result: (SRAconst x [c])
}
return false
}
-func rewriteValueMIPS_OpRsh32x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool {
+func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8x16(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8x32(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpRsh8x64(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueMIPS_OpRsh8x8(v *Value) bool {
+func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS_OpSelect0(v *Value) bool {
+func rewriteValueMIPS_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS_OpSelect0_10(v *Value) bool {
// match: (Select0 (MULTU (MOVWconst [c]) (MOVWconst [d])))
// cond:
// result: (MOVWconst [(c*d)>>32])
}
return false
}
-func rewriteValueMIPS_OpSelect1(v *Value) bool {
+func rewriteValueMIPS_OpSelect1_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS_OpSelect1_10(v *Value) bool {
// match: (Select1 (MULTU (MOVWconst [c]) (MOVWconst [d])))
// cond:
// result: (MOVWconst [int64(int32(uint32(c)*uint32(d)))])
}
return false
}
-func rewriteValueMIPS_OpSignExt16to32(v *Value) bool {
+func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueMIPS_OpSignExt8to16(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueMIPS_OpSignExt8to32(v *Value) bool {
+func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueMIPS_OpSignmask(v *Value) bool {
+func rewriteValueMIPS_OpSignmask_0(v *Value) bool {
// match: (Signmask x)
// cond:
// result: (SRAconst x [31])
return true
}
}
-func rewriteValueMIPS_OpSlicemask(v *Value) bool {
+func rewriteValueMIPS_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueMIPS_OpSqrt(v *Value) bool {
+func rewriteValueMIPS_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (SQRTD x)
return true
}
}
-func rewriteValueMIPS_OpStaticCall(v *Value) bool {
+func rewriteValueMIPS_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueMIPS_OpStore(v *Value) bool {
+func rewriteValueMIPS_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
}
return false
}
-func rewriteValueMIPS_OpSub16(v *Value) bool {
+func rewriteValueMIPS_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueMIPS_OpSub32(v *Value) bool {
+func rewriteValueMIPS_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueMIPS_OpSub32F(v *Value) bool {
+func rewriteValueMIPS_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
return true
}
}
-func rewriteValueMIPS_OpSub32withcarry(v *Value) bool {
+func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub32withcarry <t> x y c)
return true
}
}
-func rewriteValueMIPS_OpSub64F(v *Value) bool {
+func rewriteValueMIPS_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
return true
}
}
-func rewriteValueMIPS_OpSub8(v *Value) bool {
+func rewriteValueMIPS_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueMIPS_OpSubPtr(v *Value) bool {
+func rewriteValueMIPS_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueMIPS_OpTrunc16to8(v *Value) bool {
+func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS_OpTrunc32to16(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS_OpTrunc32to8(v *Value) bool {
+func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS_OpXor16(v *Value) bool {
+func rewriteValueMIPS_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS_OpXor32(v *Value) bool {
+func rewriteValueMIPS_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS_OpXor8(v *Value) bool {
+func rewriteValueMIPS_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS_OpZero(v *Value) bool {
+func rewriteValueMIPS_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [12] {t} ptr mem)
// cond: t.(Type).Alignment()%4 == 0
// result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem)))
}
return false
}
-func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool {
+func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueMIPS_OpZeromask(v *Value) bool {
+func rewriteValueMIPS_OpZeromask_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
func rewriteValueMIPS64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueMIPS64_OpAdd16(v)
+ return rewriteValueMIPS64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueMIPS64_OpAdd32(v)
+ return rewriteValueMIPS64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueMIPS64_OpAdd32F(v)
+ return rewriteValueMIPS64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueMIPS64_OpAdd64(v)
+ return rewriteValueMIPS64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueMIPS64_OpAdd64F(v)
+ return rewriteValueMIPS64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueMIPS64_OpAdd8(v)
+ return rewriteValueMIPS64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueMIPS64_OpAddPtr(v)
+ return rewriteValueMIPS64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueMIPS64_OpAddr(v)
+ return rewriteValueMIPS64_OpAddr_0(v)
case OpAnd16:
- return rewriteValueMIPS64_OpAnd16(v)
+ return rewriteValueMIPS64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueMIPS64_OpAnd32(v)
+ return rewriteValueMIPS64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueMIPS64_OpAnd64(v)
+ return rewriteValueMIPS64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueMIPS64_OpAnd8(v)
+ return rewriteValueMIPS64_OpAnd8_0(v)
case OpAndB:
- return rewriteValueMIPS64_OpAndB(v)
+ return rewriteValueMIPS64_OpAndB_0(v)
case OpAvg64u:
- return rewriteValueMIPS64_OpAvg64u(v)
+ return rewriteValueMIPS64_OpAvg64u_0(v)
case OpClosureCall:
- return rewriteValueMIPS64_OpClosureCall(v)
+ return rewriteValueMIPS64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueMIPS64_OpCom16(v)
+ return rewriteValueMIPS64_OpCom16_0(v)
case OpCom32:
- return rewriteValueMIPS64_OpCom32(v)
+ return rewriteValueMIPS64_OpCom32_0(v)
case OpCom64:
- return rewriteValueMIPS64_OpCom64(v)
+ return rewriteValueMIPS64_OpCom64_0(v)
case OpCom8:
- return rewriteValueMIPS64_OpCom8(v)
+ return rewriteValueMIPS64_OpCom8_0(v)
case OpConst16:
- return rewriteValueMIPS64_OpConst16(v)
+ return rewriteValueMIPS64_OpConst16_0(v)
case OpConst32:
- return rewriteValueMIPS64_OpConst32(v)
+ return rewriteValueMIPS64_OpConst32_0(v)
case OpConst32F:
- return rewriteValueMIPS64_OpConst32F(v)
+ return rewriteValueMIPS64_OpConst32F_0(v)
case OpConst64:
- return rewriteValueMIPS64_OpConst64(v)
+ return rewriteValueMIPS64_OpConst64_0(v)
case OpConst64F:
- return rewriteValueMIPS64_OpConst64F(v)
+ return rewriteValueMIPS64_OpConst64F_0(v)
case OpConst8:
- return rewriteValueMIPS64_OpConst8(v)
+ return rewriteValueMIPS64_OpConst8_0(v)
case OpConstBool:
- return rewriteValueMIPS64_OpConstBool(v)
+ return rewriteValueMIPS64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueMIPS64_OpConstNil(v)
+ return rewriteValueMIPS64_OpConstNil_0(v)
case OpConvert:
- return rewriteValueMIPS64_OpConvert(v)
+ return rewriteValueMIPS64_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValueMIPS64_OpCvt32Fto32(v)
+ return rewriteValueMIPS64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueMIPS64_OpCvt32Fto64(v)
+ return rewriteValueMIPS64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueMIPS64_OpCvt32Fto64F(v)
+ return rewriteValueMIPS64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueMIPS64_OpCvt32to32F(v)
+ return rewriteValueMIPS64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueMIPS64_OpCvt32to64F(v)
+ return rewriteValueMIPS64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueMIPS64_OpCvt64Fto32(v)
+ return rewriteValueMIPS64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueMIPS64_OpCvt64Fto32F(v)
+ return rewriteValueMIPS64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueMIPS64_OpCvt64Fto64(v)
+ return rewriteValueMIPS64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueMIPS64_OpCvt64to32F(v)
+ return rewriteValueMIPS64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueMIPS64_OpCvt64to64F(v)
+ return rewriteValueMIPS64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueMIPS64_OpDiv16(v)
+ return rewriteValueMIPS64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueMIPS64_OpDiv16u(v)
+ return rewriteValueMIPS64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueMIPS64_OpDiv32(v)
+ return rewriteValueMIPS64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueMIPS64_OpDiv32F(v)
+ return rewriteValueMIPS64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueMIPS64_OpDiv32u(v)
+ return rewriteValueMIPS64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueMIPS64_OpDiv64(v)
+ return rewriteValueMIPS64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueMIPS64_OpDiv64F(v)
+ return rewriteValueMIPS64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueMIPS64_OpDiv64u(v)
+ return rewriteValueMIPS64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueMIPS64_OpDiv8(v)
+ return rewriteValueMIPS64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueMIPS64_OpDiv8u(v)
+ return rewriteValueMIPS64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueMIPS64_OpEq16(v)
+ return rewriteValueMIPS64_OpEq16_0(v)
case OpEq32:
- return rewriteValueMIPS64_OpEq32(v)
+ return rewriteValueMIPS64_OpEq32_0(v)
case OpEq32F:
- return rewriteValueMIPS64_OpEq32F(v)
+ return rewriteValueMIPS64_OpEq32F_0(v)
case OpEq64:
- return rewriteValueMIPS64_OpEq64(v)
+ return rewriteValueMIPS64_OpEq64_0(v)
case OpEq64F:
- return rewriteValueMIPS64_OpEq64F(v)
+ return rewriteValueMIPS64_OpEq64F_0(v)
case OpEq8:
- return rewriteValueMIPS64_OpEq8(v)
+ return rewriteValueMIPS64_OpEq8_0(v)
case OpEqB:
- return rewriteValueMIPS64_OpEqB(v)
+ return rewriteValueMIPS64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueMIPS64_OpEqPtr(v)
+ return rewriteValueMIPS64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueMIPS64_OpGeq16(v)
+ return rewriteValueMIPS64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueMIPS64_OpGeq16U(v)
+ return rewriteValueMIPS64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueMIPS64_OpGeq32(v)
+ return rewriteValueMIPS64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueMIPS64_OpGeq32F(v)
+ return rewriteValueMIPS64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueMIPS64_OpGeq32U(v)
+ return rewriteValueMIPS64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueMIPS64_OpGeq64(v)
+ return rewriteValueMIPS64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueMIPS64_OpGeq64F(v)
+ return rewriteValueMIPS64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueMIPS64_OpGeq64U(v)
+ return rewriteValueMIPS64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueMIPS64_OpGeq8(v)
+ return rewriteValueMIPS64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueMIPS64_OpGeq8U(v)
+ return rewriteValueMIPS64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueMIPS64_OpGetClosurePtr(v)
+ return rewriteValueMIPS64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValueMIPS64_OpGreater16(v)
+ return rewriteValueMIPS64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueMIPS64_OpGreater16U(v)
+ return rewriteValueMIPS64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueMIPS64_OpGreater32(v)
+ return rewriteValueMIPS64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueMIPS64_OpGreater32F(v)
+ return rewriteValueMIPS64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueMIPS64_OpGreater32U(v)
+ return rewriteValueMIPS64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueMIPS64_OpGreater64(v)
+ return rewriteValueMIPS64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueMIPS64_OpGreater64F(v)
+ return rewriteValueMIPS64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueMIPS64_OpGreater64U(v)
+ return rewriteValueMIPS64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueMIPS64_OpGreater8(v)
+ return rewriteValueMIPS64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueMIPS64_OpGreater8U(v)
+ return rewriteValueMIPS64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueMIPS64_OpHmul32(v)
+ return rewriteValueMIPS64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueMIPS64_OpHmul32u(v)
+ return rewriteValueMIPS64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueMIPS64_OpHmul64(v)
+ return rewriteValueMIPS64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueMIPS64_OpHmul64u(v)
+ return rewriteValueMIPS64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValueMIPS64_OpInterCall(v)
+ return rewriteValueMIPS64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueMIPS64_OpIsInBounds(v)
+ return rewriteValueMIPS64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueMIPS64_OpIsNonNil(v)
+ return rewriteValueMIPS64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueMIPS64_OpIsSliceInBounds(v)
+ return rewriteValueMIPS64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueMIPS64_OpLeq16(v)
+ return rewriteValueMIPS64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueMIPS64_OpLeq16U(v)
+ return rewriteValueMIPS64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueMIPS64_OpLeq32(v)
+ return rewriteValueMIPS64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueMIPS64_OpLeq32F(v)
+ return rewriteValueMIPS64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueMIPS64_OpLeq32U(v)
+ return rewriteValueMIPS64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueMIPS64_OpLeq64(v)
+ return rewriteValueMIPS64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueMIPS64_OpLeq64F(v)
+ return rewriteValueMIPS64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueMIPS64_OpLeq64U(v)
+ return rewriteValueMIPS64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueMIPS64_OpLeq8(v)
+ return rewriteValueMIPS64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueMIPS64_OpLeq8U(v)
+ return rewriteValueMIPS64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueMIPS64_OpLess16(v)
+ return rewriteValueMIPS64_OpLess16_0(v)
case OpLess16U:
- return rewriteValueMIPS64_OpLess16U(v)
+ return rewriteValueMIPS64_OpLess16U_0(v)
case OpLess32:
- return rewriteValueMIPS64_OpLess32(v)
+ return rewriteValueMIPS64_OpLess32_0(v)
case OpLess32F:
- return rewriteValueMIPS64_OpLess32F(v)
+ return rewriteValueMIPS64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueMIPS64_OpLess32U(v)
+ return rewriteValueMIPS64_OpLess32U_0(v)
case OpLess64:
- return rewriteValueMIPS64_OpLess64(v)
+ return rewriteValueMIPS64_OpLess64_0(v)
case OpLess64F:
- return rewriteValueMIPS64_OpLess64F(v)
+ return rewriteValueMIPS64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueMIPS64_OpLess64U(v)
+ return rewriteValueMIPS64_OpLess64U_0(v)
case OpLess8:
- return rewriteValueMIPS64_OpLess8(v)
+ return rewriteValueMIPS64_OpLess8_0(v)
case OpLess8U:
- return rewriteValueMIPS64_OpLess8U(v)
+ return rewriteValueMIPS64_OpLess8U_0(v)
case OpLoad:
- return rewriteValueMIPS64_OpLoad(v)
+ return rewriteValueMIPS64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueMIPS64_OpLsh16x16(v)
+ return rewriteValueMIPS64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueMIPS64_OpLsh16x32(v)
+ return rewriteValueMIPS64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueMIPS64_OpLsh16x64(v)
+ return rewriteValueMIPS64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueMIPS64_OpLsh16x8(v)
+ return rewriteValueMIPS64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueMIPS64_OpLsh32x16(v)
+ return rewriteValueMIPS64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueMIPS64_OpLsh32x32(v)
+ return rewriteValueMIPS64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueMIPS64_OpLsh32x64(v)
+ return rewriteValueMIPS64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueMIPS64_OpLsh32x8(v)
+ return rewriteValueMIPS64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueMIPS64_OpLsh64x16(v)
+ return rewriteValueMIPS64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueMIPS64_OpLsh64x32(v)
+ return rewriteValueMIPS64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueMIPS64_OpLsh64x64(v)
+ return rewriteValueMIPS64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueMIPS64_OpLsh64x8(v)
+ return rewriteValueMIPS64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueMIPS64_OpLsh8x16(v)
+ return rewriteValueMIPS64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueMIPS64_OpLsh8x32(v)
+ return rewriteValueMIPS64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueMIPS64_OpLsh8x64(v)
+ return rewriteValueMIPS64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueMIPS64_OpLsh8x8(v)
+ return rewriteValueMIPS64_OpLsh8x8_0(v)
case OpMIPS64ADDV:
- return rewriteValueMIPS64_OpMIPS64ADDV(v)
+ return rewriteValueMIPS64_OpMIPS64ADDV_0(v)
case OpMIPS64ADDVconst:
- return rewriteValueMIPS64_OpMIPS64ADDVconst(v)
+ return rewriteValueMIPS64_OpMIPS64ADDVconst_0(v)
case OpMIPS64AND:
- return rewriteValueMIPS64_OpMIPS64AND(v)
+ return rewriteValueMIPS64_OpMIPS64AND_0(v)
case OpMIPS64ANDconst:
- return rewriteValueMIPS64_OpMIPS64ANDconst(v)
+ return rewriteValueMIPS64_OpMIPS64ANDconst_0(v)
case OpMIPS64MOVBUload:
- return rewriteValueMIPS64_OpMIPS64MOVBUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUload_0(v)
case OpMIPS64MOVBUreg:
- return rewriteValueMIPS64_OpMIPS64MOVBUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v)
case OpMIPS64MOVBload:
- return rewriteValueMIPS64_OpMIPS64MOVBload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBload_0(v)
case OpMIPS64MOVBreg:
- return rewriteValueMIPS64_OpMIPS64MOVBreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBreg_0(v)
case OpMIPS64MOVBstore:
- return rewriteValueMIPS64_OpMIPS64MOVBstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstore_0(v)
case OpMIPS64MOVBstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v)
case OpMIPS64MOVDload:
- return rewriteValueMIPS64_OpMIPS64MOVDload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDload_0(v)
case OpMIPS64MOVDstore:
- return rewriteValueMIPS64_OpMIPS64MOVDstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVDstore_0(v)
case OpMIPS64MOVFload:
- return rewriteValueMIPS64_OpMIPS64MOVFload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFload_0(v)
case OpMIPS64MOVFstore:
- return rewriteValueMIPS64_OpMIPS64MOVFstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVFstore_0(v)
case OpMIPS64MOVHUload:
- return rewriteValueMIPS64_OpMIPS64MOVHUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUload_0(v)
case OpMIPS64MOVHUreg:
- return rewriteValueMIPS64_OpMIPS64MOVHUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v)
case OpMIPS64MOVHload:
- return rewriteValueMIPS64_OpMIPS64MOVHload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHload_0(v)
case OpMIPS64MOVHreg:
- return rewriteValueMIPS64_OpMIPS64MOVHreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHreg_0(v)
case OpMIPS64MOVHstore:
- return rewriteValueMIPS64_OpMIPS64MOVHstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstore_0(v)
case OpMIPS64MOVHstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v)
case OpMIPS64MOVVload:
- return rewriteValueMIPS64_OpMIPS64MOVVload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVload_0(v)
case OpMIPS64MOVVreg:
- return rewriteValueMIPS64_OpMIPS64MOVVreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVreg_0(v)
case OpMIPS64MOVVstore:
- return rewriteValueMIPS64_OpMIPS64MOVVstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstore_0(v)
case OpMIPS64MOVVstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v)
case OpMIPS64MOVWUload:
- return rewriteValueMIPS64_OpMIPS64MOVWUload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUload_0(v)
case OpMIPS64MOVWUreg:
- return rewriteValueMIPS64_OpMIPS64MOVWUreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v)
case OpMIPS64MOVWload:
- return rewriteValueMIPS64_OpMIPS64MOVWload(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWload_0(v)
case OpMIPS64MOVWreg:
- return rewriteValueMIPS64_OpMIPS64MOVWreg(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWreg_0(v) || rewriteValueMIPS64_OpMIPS64MOVWreg_10(v)
case OpMIPS64MOVWstore:
- return rewriteValueMIPS64_OpMIPS64MOVWstore(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstore_0(v)
case OpMIPS64MOVWstorezero:
- return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v)
+ return rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v)
case OpMIPS64NEGV:
- return rewriteValueMIPS64_OpMIPS64NEGV(v)
+ return rewriteValueMIPS64_OpMIPS64NEGV_0(v)
case OpMIPS64NOR:
- return rewriteValueMIPS64_OpMIPS64NOR(v)
+ return rewriteValueMIPS64_OpMIPS64NOR_0(v)
case OpMIPS64NORconst:
- return rewriteValueMIPS64_OpMIPS64NORconst(v)
+ return rewriteValueMIPS64_OpMIPS64NORconst_0(v)
case OpMIPS64OR:
- return rewriteValueMIPS64_OpMIPS64OR(v)
+ return rewriteValueMIPS64_OpMIPS64OR_0(v)
case OpMIPS64ORconst:
- return rewriteValueMIPS64_OpMIPS64ORconst(v)
+ return rewriteValueMIPS64_OpMIPS64ORconst_0(v)
case OpMIPS64SGT:
- return rewriteValueMIPS64_OpMIPS64SGT(v)
+ return rewriteValueMIPS64_OpMIPS64SGT_0(v)
case OpMIPS64SGTU:
- return rewriteValueMIPS64_OpMIPS64SGTU(v)
+ return rewriteValueMIPS64_OpMIPS64SGTU_0(v)
case OpMIPS64SGTUconst:
- return rewriteValueMIPS64_OpMIPS64SGTUconst(v)
+ return rewriteValueMIPS64_OpMIPS64SGTUconst_0(v)
case OpMIPS64SGTconst:
- return rewriteValueMIPS64_OpMIPS64SGTconst(v)
+ return rewriteValueMIPS64_OpMIPS64SGTconst_0(v) || rewriteValueMIPS64_OpMIPS64SGTconst_10(v)
case OpMIPS64SLLV:
- return rewriteValueMIPS64_OpMIPS64SLLV(v)
+ return rewriteValueMIPS64_OpMIPS64SLLV_0(v)
case OpMIPS64SLLVconst:
- return rewriteValueMIPS64_OpMIPS64SLLVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SLLVconst_0(v)
case OpMIPS64SRAV:
- return rewriteValueMIPS64_OpMIPS64SRAV(v)
+ return rewriteValueMIPS64_OpMIPS64SRAV_0(v)
case OpMIPS64SRAVconst:
- return rewriteValueMIPS64_OpMIPS64SRAVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SRAVconst_0(v)
case OpMIPS64SRLV:
- return rewriteValueMIPS64_OpMIPS64SRLV(v)
+ return rewriteValueMIPS64_OpMIPS64SRLV_0(v)
case OpMIPS64SRLVconst:
- return rewriteValueMIPS64_OpMIPS64SRLVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SRLVconst_0(v)
case OpMIPS64SUBV:
- return rewriteValueMIPS64_OpMIPS64SUBV(v)
+ return rewriteValueMIPS64_OpMIPS64SUBV_0(v)
case OpMIPS64SUBVconst:
- return rewriteValueMIPS64_OpMIPS64SUBVconst(v)
+ return rewriteValueMIPS64_OpMIPS64SUBVconst_0(v)
case OpMIPS64XOR:
- return rewriteValueMIPS64_OpMIPS64XOR(v)
+ return rewriteValueMIPS64_OpMIPS64XOR_0(v)
case OpMIPS64XORconst:
- return rewriteValueMIPS64_OpMIPS64XORconst(v)
+ return rewriteValueMIPS64_OpMIPS64XORconst_0(v)
case OpMod16:
- return rewriteValueMIPS64_OpMod16(v)
+ return rewriteValueMIPS64_OpMod16_0(v)
case OpMod16u:
- return rewriteValueMIPS64_OpMod16u(v)
+ return rewriteValueMIPS64_OpMod16u_0(v)
case OpMod32:
- return rewriteValueMIPS64_OpMod32(v)
+ return rewriteValueMIPS64_OpMod32_0(v)
case OpMod32u:
- return rewriteValueMIPS64_OpMod32u(v)
+ return rewriteValueMIPS64_OpMod32u_0(v)
case OpMod64:
- return rewriteValueMIPS64_OpMod64(v)
+ return rewriteValueMIPS64_OpMod64_0(v)
case OpMod64u:
- return rewriteValueMIPS64_OpMod64u(v)
+ return rewriteValueMIPS64_OpMod64u_0(v)
case OpMod8:
- return rewriteValueMIPS64_OpMod8(v)
+ return rewriteValueMIPS64_OpMod8_0(v)
case OpMod8u:
- return rewriteValueMIPS64_OpMod8u(v)
+ return rewriteValueMIPS64_OpMod8u_0(v)
case OpMove:
- return rewriteValueMIPS64_OpMove(v)
+ return rewriteValueMIPS64_OpMove_0(v) || rewriteValueMIPS64_OpMove_10(v)
case OpMul16:
- return rewriteValueMIPS64_OpMul16(v)
+ return rewriteValueMIPS64_OpMul16_0(v)
case OpMul32:
- return rewriteValueMIPS64_OpMul32(v)
+ return rewriteValueMIPS64_OpMul32_0(v)
case OpMul32F:
- return rewriteValueMIPS64_OpMul32F(v)
+ return rewriteValueMIPS64_OpMul32F_0(v)
case OpMul64:
- return rewriteValueMIPS64_OpMul64(v)
+ return rewriteValueMIPS64_OpMul64_0(v)
case OpMul64F:
- return rewriteValueMIPS64_OpMul64F(v)
+ return rewriteValueMIPS64_OpMul64F_0(v)
case OpMul8:
- return rewriteValueMIPS64_OpMul8(v)
+ return rewriteValueMIPS64_OpMul8_0(v)
case OpNeg16:
- return rewriteValueMIPS64_OpNeg16(v)
+ return rewriteValueMIPS64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueMIPS64_OpNeg32(v)
+ return rewriteValueMIPS64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueMIPS64_OpNeg32F(v)
+ return rewriteValueMIPS64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueMIPS64_OpNeg64(v)
+ return rewriteValueMIPS64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueMIPS64_OpNeg64F(v)
+ return rewriteValueMIPS64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueMIPS64_OpNeg8(v)
+ return rewriteValueMIPS64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueMIPS64_OpNeq16(v)
+ return rewriteValueMIPS64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueMIPS64_OpNeq32(v)
+ return rewriteValueMIPS64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueMIPS64_OpNeq32F(v)
+ return rewriteValueMIPS64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueMIPS64_OpNeq64(v)
+ return rewriteValueMIPS64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueMIPS64_OpNeq64F(v)
+ return rewriteValueMIPS64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueMIPS64_OpNeq8(v)
+ return rewriteValueMIPS64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueMIPS64_OpNeqB(v)
+ return rewriteValueMIPS64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueMIPS64_OpNeqPtr(v)
+ return rewriteValueMIPS64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueMIPS64_OpNilCheck(v)
+ return rewriteValueMIPS64_OpNilCheck_0(v)
case OpNot:
- return rewriteValueMIPS64_OpNot(v)
+ return rewriteValueMIPS64_OpNot_0(v)
case OpOffPtr:
- return rewriteValueMIPS64_OpOffPtr(v)
+ return rewriteValueMIPS64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueMIPS64_OpOr16(v)
+ return rewriteValueMIPS64_OpOr16_0(v)
case OpOr32:
- return rewriteValueMIPS64_OpOr32(v)
+ return rewriteValueMIPS64_OpOr32_0(v)
case OpOr64:
- return rewriteValueMIPS64_OpOr64(v)
+ return rewriteValueMIPS64_OpOr64_0(v)
case OpOr8:
- return rewriteValueMIPS64_OpOr8(v)
+ return rewriteValueMIPS64_OpOr8_0(v)
case OpOrB:
- return rewriteValueMIPS64_OpOrB(v)
+ return rewriteValueMIPS64_OpOrB_0(v)
case OpRound32F:
- return rewriteValueMIPS64_OpRound32F(v)
+ return rewriteValueMIPS64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueMIPS64_OpRound64F(v)
+ return rewriteValueMIPS64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueMIPS64_OpRsh16Ux16(v)
+ return rewriteValueMIPS64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueMIPS64_OpRsh16Ux32(v)
+ return rewriteValueMIPS64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueMIPS64_OpRsh16Ux64(v)
+ return rewriteValueMIPS64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueMIPS64_OpRsh16Ux8(v)
+ return rewriteValueMIPS64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueMIPS64_OpRsh16x16(v)
+ return rewriteValueMIPS64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueMIPS64_OpRsh16x32(v)
+ return rewriteValueMIPS64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueMIPS64_OpRsh16x64(v)
+ return rewriteValueMIPS64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueMIPS64_OpRsh16x8(v)
+ return rewriteValueMIPS64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueMIPS64_OpRsh32Ux16(v)
+ return rewriteValueMIPS64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueMIPS64_OpRsh32Ux32(v)
+ return rewriteValueMIPS64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueMIPS64_OpRsh32Ux64(v)
+ return rewriteValueMIPS64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueMIPS64_OpRsh32Ux8(v)
+ return rewriteValueMIPS64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueMIPS64_OpRsh32x16(v)
+ return rewriteValueMIPS64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueMIPS64_OpRsh32x32(v)
+ return rewriteValueMIPS64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueMIPS64_OpRsh32x64(v)
+ return rewriteValueMIPS64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueMIPS64_OpRsh32x8(v)
+ return rewriteValueMIPS64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueMIPS64_OpRsh64Ux16(v)
+ return rewriteValueMIPS64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueMIPS64_OpRsh64Ux32(v)
+ return rewriteValueMIPS64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueMIPS64_OpRsh64Ux64(v)
+ return rewriteValueMIPS64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueMIPS64_OpRsh64Ux8(v)
+ return rewriteValueMIPS64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueMIPS64_OpRsh64x16(v)
+ return rewriteValueMIPS64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueMIPS64_OpRsh64x32(v)
+ return rewriteValueMIPS64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueMIPS64_OpRsh64x64(v)
+ return rewriteValueMIPS64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueMIPS64_OpRsh64x8(v)
+ return rewriteValueMIPS64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueMIPS64_OpRsh8Ux16(v)
+ return rewriteValueMIPS64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueMIPS64_OpRsh8Ux32(v)
+ return rewriteValueMIPS64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueMIPS64_OpRsh8Ux64(v)
+ return rewriteValueMIPS64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueMIPS64_OpRsh8Ux8(v)
+ return rewriteValueMIPS64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueMIPS64_OpRsh8x16(v)
+ return rewriteValueMIPS64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueMIPS64_OpRsh8x32(v)
+ return rewriteValueMIPS64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueMIPS64_OpRsh8x64(v)
+ return rewriteValueMIPS64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueMIPS64_OpRsh8x8(v)
+ return rewriteValueMIPS64_OpRsh8x8_0(v)
case OpSelect0:
- return rewriteValueMIPS64_OpSelect0(v)
+ return rewriteValueMIPS64_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueMIPS64_OpSelect1(v)
+ return rewriteValueMIPS64_OpSelect1_0(v) || rewriteValueMIPS64_OpSelect1_10(v) || rewriteValueMIPS64_OpSelect1_20(v)
case OpSignExt16to32:
- return rewriteValueMIPS64_OpSignExt16to32(v)
+ return rewriteValueMIPS64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueMIPS64_OpSignExt16to64(v)
+ return rewriteValueMIPS64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueMIPS64_OpSignExt32to64(v)
+ return rewriteValueMIPS64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueMIPS64_OpSignExt8to16(v)
+ return rewriteValueMIPS64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueMIPS64_OpSignExt8to32(v)
+ return rewriteValueMIPS64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueMIPS64_OpSignExt8to64(v)
+ return rewriteValueMIPS64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueMIPS64_OpSlicemask(v)
+ return rewriteValueMIPS64_OpSlicemask_0(v)
case OpStaticCall:
- return rewriteValueMIPS64_OpStaticCall(v)
+ return rewriteValueMIPS64_OpStaticCall_0(v)
case OpStore:
- return rewriteValueMIPS64_OpStore(v)
+ return rewriteValueMIPS64_OpStore_0(v)
case OpSub16:
- return rewriteValueMIPS64_OpSub16(v)
+ return rewriteValueMIPS64_OpSub16_0(v)
case OpSub32:
- return rewriteValueMIPS64_OpSub32(v)
+ return rewriteValueMIPS64_OpSub32_0(v)
case OpSub32F:
- return rewriteValueMIPS64_OpSub32F(v)
+ return rewriteValueMIPS64_OpSub32F_0(v)
case OpSub64:
- return rewriteValueMIPS64_OpSub64(v)
+ return rewriteValueMIPS64_OpSub64_0(v)
case OpSub64F:
- return rewriteValueMIPS64_OpSub64F(v)
+ return rewriteValueMIPS64_OpSub64F_0(v)
case OpSub8:
- return rewriteValueMIPS64_OpSub8(v)
+ return rewriteValueMIPS64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueMIPS64_OpSubPtr(v)
+ return rewriteValueMIPS64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueMIPS64_OpTrunc16to8(v)
+ return rewriteValueMIPS64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueMIPS64_OpTrunc32to16(v)
+ return rewriteValueMIPS64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueMIPS64_OpTrunc32to8(v)
+ return rewriteValueMIPS64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueMIPS64_OpTrunc64to16(v)
+ return rewriteValueMIPS64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueMIPS64_OpTrunc64to32(v)
+ return rewriteValueMIPS64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueMIPS64_OpTrunc64to8(v)
+ return rewriteValueMIPS64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueMIPS64_OpXor16(v)
+ return rewriteValueMIPS64_OpXor16_0(v)
case OpXor32:
- return rewriteValueMIPS64_OpXor32(v)
+ return rewriteValueMIPS64_OpXor32_0(v)
case OpXor64:
- return rewriteValueMIPS64_OpXor64(v)
+ return rewriteValueMIPS64_OpXor64_0(v)
case OpXor8:
- return rewriteValueMIPS64_OpXor8(v)
+ return rewriteValueMIPS64_OpXor8_0(v)
case OpZero:
- return rewriteValueMIPS64_OpZero(v)
+ return rewriteValueMIPS64_OpZero_0(v) || rewriteValueMIPS64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueMIPS64_OpZeroExt16to32(v)
+ return rewriteValueMIPS64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueMIPS64_OpZeroExt16to64(v)
+ return rewriteValueMIPS64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueMIPS64_OpZeroExt32to64(v)
+ return rewriteValueMIPS64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueMIPS64_OpZeroExt8to16(v)
+ return rewriteValueMIPS64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueMIPS64_OpZeroExt8to32(v)
+ return rewriteValueMIPS64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueMIPS64_OpZeroExt8to64(v)
+ return rewriteValueMIPS64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueMIPS64_OpAdd16(v *Value) bool {
+func rewriteValueMIPS64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDV x y)
return true
}
}
-func rewriteValueMIPS64_OpAdd32(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDV x y)
return true
}
}
-func rewriteValueMIPS64_OpAdd32F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (ADDF x y)
return true
}
}
-func rewriteValueMIPS64_OpAdd64(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADDV x y)
return true
}
}
-func rewriteValueMIPS64_OpAdd64F(v *Value) bool {
+func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (ADDD x y)
return true
}
}
-func rewriteValueMIPS64_OpAdd8(v *Value) bool {
+func rewriteValueMIPS64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDV x y)
return true
}
}
-func rewriteValueMIPS64_OpAddPtr(v *Value) bool {
+func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADDV x y)
return true
}
}
-func rewriteValueMIPS64_OpAddr(v *Value) bool {
+func rewriteValueMIPS64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVVaddr {sym} base)
return true
}
}
-func rewriteValueMIPS64_OpAnd16(v *Value) bool {
+func rewriteValueMIPS64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS64_OpAnd32(v *Value) bool {
+func rewriteValueMIPS64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS64_OpAnd64(v *Value) bool {
+func rewriteValueMIPS64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS64_OpAnd8(v *Value) bool {
+func rewriteValueMIPS64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS64_OpAndB(v *Value) bool {
+func rewriteValueMIPS64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueMIPS64_OpAvg64u(v *Value) bool {
+func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
return true
}
}
-func rewriteValueMIPS64_OpClosureCall(v *Value) bool {
+func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueMIPS64_OpCom16(v *Value) bool {
+func rewriteValueMIPS64_OpCom16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpCom32(v *Value) bool {
+func rewriteValueMIPS64_OpCom32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpCom64(v *Value) bool {
+func rewriteValueMIPS64_OpCom64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpCom8(v *Value) bool {
+func rewriteValueMIPS64_OpCom8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpConst16(v *Value) bool {
+func rewriteValueMIPS64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVVconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConst32(v *Value) bool {
+func rewriteValueMIPS64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVVconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConst32F(v *Value) bool {
+func rewriteValueMIPS64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (MOVFconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConst64(v *Value) bool {
+func rewriteValueMIPS64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVVconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConst64F(v *Value) bool {
+func rewriteValueMIPS64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConst8(v *Value) bool {
+func rewriteValueMIPS64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVVconst [val])
return true
}
}
-func rewriteValueMIPS64_OpConstBool(v *Value) bool {
+func rewriteValueMIPS64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVVconst [b])
return true
}
}
-func rewriteValueMIPS64_OpConstNil(v *Value) bool {
+func rewriteValueMIPS64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVVconst [0])
return true
}
}
-func rewriteValueMIPS64_OpConvert(v *Value) bool {
+func rewriteValueMIPS64_OpConvert_0(v *Value) bool {
// match: (Convert x mem)
// cond:
// result: (MOVVconvert x mem)
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (TRUNCFW x)
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (TRUNCFV x)
return true
}
}
-func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (MOVFD x)
return true
}
}
-func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (MOVWF x)
return true
}
}
-func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (MOVWD x)
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (TRUNCDW x)
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (MOVDF x)
return true
}
}
-func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (TRUNCDV x)
return true
}
}
-func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (MOVVF x)
return true
}
}
-func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool {
+func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (MOVVD x)
return true
}
}
-func rewriteValueMIPS64_OpDiv16(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv16u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv32(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv32F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (DIVF x y)
return true
}
}
-func rewriteValueMIPS64_OpDiv32u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv64(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv64F(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (DIVD x y)
return true
}
}
-func rewriteValueMIPS64_OpDiv64u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv8(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpDiv8u(v *Value) bool {
+func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEq16(v *Value) bool {
+func rewriteValueMIPS64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEq32(v *Value) bool {
+func rewriteValueMIPS64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEq32F(v *Value) bool {
+func rewriteValueMIPS64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValueMIPS64_OpEq64(v *Value) bool {
+func rewriteValueMIPS64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEq64F(v *Value) bool {
+func rewriteValueMIPS64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValueMIPS64_OpEq8(v *Value) bool {
+func rewriteValueMIPS64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEqB(v *Value) bool {
+func rewriteValueMIPS64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpEqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq16(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq32(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValueMIPS64_OpGeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq64(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValueMIPS64_OpGeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq8(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool {
+func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueMIPS64_OpGreater16(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGreater16U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGreater32(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGreater32F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValueMIPS64_OpGreater32U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGreater64(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64_0(v *Value) bool {
// match: (Greater64 x y)
// cond:
// result: (SGT x y)
return true
}
}
-func rewriteValueMIPS64_OpGreater64F(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValueMIPS64_OpGreater64U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool {
// match: (Greater64U x y)
// cond:
// result: (SGTU x y)
return true
}
}
-func rewriteValueMIPS64_OpGreater8(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpGreater8U(v *Value) bool {
+func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpHmul32(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpHmul32u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpHmul64(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpHmul64u(v *Value) bool {
+func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpInterCall(v *Value) bool {
+func rewriteValueMIPS64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueMIPS64_OpIsInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds idx len)
// cond:
// result: (SGTU len idx)
return true
}
}
-func rewriteValueMIPS64_OpIsNonNil(v *Value) bool {
+func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq16(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq16U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq32(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValueMIPS64_OpLeq32U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq64(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValueMIPS64_OpLeq64U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq8(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLeq8U(v *Value) bool {
+func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess16(v *Value) bool {
+func rewriteValueMIPS64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess16U(v *Value) bool {
+func rewriteValueMIPS64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess32(v *Value) bool {
+func rewriteValueMIPS64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess32F(v *Value) bool {
+func rewriteValueMIPS64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValueMIPS64_OpLess32U(v *Value) bool {
+func rewriteValueMIPS64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess64(v *Value) bool {
+func rewriteValueMIPS64_OpLess64_0(v *Value) bool {
// match: (Less64 x y)
// cond:
// result: (SGT y x)
return true
}
}
-func rewriteValueMIPS64_OpLess64F(v *Value) bool {
+func rewriteValueMIPS64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValueMIPS64_OpLess64U(v *Value) bool {
+func rewriteValueMIPS64_OpLess64U_0(v *Value) bool {
// match: (Less64U x y)
// cond:
// result: (SGTU y x)
return true
}
}
-func rewriteValueMIPS64_OpLess8(v *Value) bool {
+func rewriteValueMIPS64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLess8U(v *Value) bool {
+func rewriteValueMIPS64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLoad(v *Value) bool {
+func rewriteValueMIPS64_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: t.IsBoolean()
// result: (MOVBUload ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpLsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpLsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool {
// match: (ADDV x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ADDVconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool {
// match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr))
// cond:
// result: (MOVVaddr [off1+off2] {sym} ptr)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool {
// match: (AND x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ANDconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool {
// match: (ANDconst [0] _)
// cond:
// result: (MOVVconst [0])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool {
// match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool {
// match: (MOVBUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool {
// match: (MOVBreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVBstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVBstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool {
// match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVFload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool {
// match: (MOVFstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVFstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool {
// match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool {
// match: (MOVHUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool {
// match: (MOVHreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVHstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVHstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool {
// match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVVload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool {
// match: (MOVVreg x)
// cond: x.Uses == 1
// result: (MOVVnop x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool {
// match: (MOVVstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVVstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool {
// match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVVstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool {
// match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWUload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool {
// match: (MOVWUreg x:(MOVBUload _ _))
// cond:
// result: (MOVVreg x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVVreg x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMIPS64MOVWreg_10(v *Value) bool {
// match: (MOVWreg (MOVVconst [c]))
// cond:
// result: (MOVVconst [int64(int32(c))])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDVconst [off2] ptr) val mem)
// cond: is32Bit(off1+off2)
// result: (MOVWstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem)
// cond: is32Bit(off1+off2)
// result: (MOVWstorezero [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool {
// match: (NEGV (MOVVconst [c]))
// cond:
// result: (MOVVconst [-c])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool {
// match: (NOR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (NORconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool {
// match: (NORconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [^(c|d)])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool {
// match: (OR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (ORconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool {
// match: (SGT (MOVVconst [c]) x)
// cond: is32Bit(c)
// result: (SGTconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool {
// match: (SGTU (MOVVconst [c]) x)
// cond: is32Bit(c)
// result: (SGTUconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool {
// match: (SGTUconst [c] (MOVVconst [d]))
// cond: uint64(c)>uint64(d)
// result: (MOVVconst [1])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool {
// match: (SGTconst [c] (MOVVconst [d]))
// cond: int64(c)>int64(d)
// result: (MOVVconst [1])
v.AuxInt = 0
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool {
// match: (SGTconst [c] (MOVWUreg _))
// cond: int64(c) < 0
// result: (MOVVconst [0])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool {
// match: (SLLV _ (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (MOVVconst [0])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SLLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SLLVconst_0(v *Value) bool {
// match: (SLLVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(d)<<uint64(c)])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAV_0(v *Value) bool {
// match: (SRAV x (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (SRAVconst x [63])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool {
// match: (SRAVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(d)>>uint64(c)])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool {
// match: (SRLV _ (MOVVconst [c]))
// cond: uint64(c)>=64
// result: (MOVVconst [0])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool {
// match: (SRLVconst [c] (MOVVconst [d]))
// cond:
// result: (MOVVconst [int64(uint64(d)>>uint64(c))])
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool {
// match: (SUBV x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (SUBVconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool {
// match: (SUBVconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool {
// match: (XOR x (MOVVconst [c]))
// cond: is32Bit(c)
// result: (XORconst [c] x)
}
return false
}
-func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool {
+func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueMIPS64_OpMod16(v *Value) bool {
+func rewriteValueMIPS64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod16u(v *Value) bool {
+func rewriteValueMIPS64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod32(v *Value) bool {
+func rewriteValueMIPS64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod32u(v *Value) bool {
+func rewriteValueMIPS64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod64(v *Value) bool {
+func rewriteValueMIPS64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod64u(v *Value) bool {
+func rewriteValueMIPS64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod8(v *Value) bool {
+func rewriteValueMIPS64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMod8u(v *Value) bool {
+func rewriteValueMIPS64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMove(v *Value) bool {
+func rewriteValueMIPS64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Move [0] _ _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [3] dst src mem)
// cond:
// result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem)))
}
return false
}
-func rewriteValueMIPS64_OpMul16(v *Value) bool {
+func rewriteValueMIPS64_OpMul16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMul32(v *Value) bool {
+func rewriteValueMIPS64_OpMul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMul32F(v *Value) bool {
+func rewriteValueMIPS64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (MULF x y)
return true
}
}
-func rewriteValueMIPS64_OpMul64(v *Value) bool {
+func rewriteValueMIPS64_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpMul64F(v *Value) bool {
+func rewriteValueMIPS64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (MULD x y)
return true
}
}
-func rewriteValueMIPS64_OpMul8(v *Value) bool {
+func rewriteValueMIPS64_OpMul8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNeg16(v *Value) bool {
+func rewriteValueMIPS64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEGV x)
return true
}
}
-func rewriteValueMIPS64_OpNeg32(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGV x)
return true
}
}
-func rewriteValueMIPS64_OpNeg32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (NEGF x)
return true
}
}
-func rewriteValueMIPS64_OpNeg64(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEGV x)
return true
}
}
-func rewriteValueMIPS64_OpNeg64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (NEGD x)
return true
}
}
-func rewriteValueMIPS64_OpNeg8(v *Value) bool {
+func rewriteValueMIPS64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEGV x)
return true
}
}
-func rewriteValueMIPS64_OpNeq16(v *Value) bool {
+func rewriteValueMIPS64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNeq32(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNeq32F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValueMIPS64_OpNeq64(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNeq64F(v *Value) bool {
+func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValueMIPS64_OpNeq8(v *Value) bool {
+func rewriteValueMIPS64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNeqB(v *Value) bool {
+func rewriteValueMIPS64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS64_OpNeqPtr(v *Value) bool {
+func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpNilCheck(v *Value) bool {
+func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueMIPS64_OpNot(v *Value) bool {
+func rewriteValueMIPS64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
return true
}
}
-func rewriteValueMIPS64_OpOffPtr(v *Value) bool {
+func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool {
// match: (OffPtr [off] ptr:(SP))
// cond:
// result: (MOVVaddr [off] ptr)
return true
}
}
-func rewriteValueMIPS64_OpOr16(v *Value) bool {
+func rewriteValueMIPS64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS64_OpOr32(v *Value) bool {
+func rewriteValueMIPS64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS64_OpOr64(v *Value) bool {
+func rewriteValueMIPS64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS64_OpOr8(v *Value) bool {
+func rewriteValueMIPS64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS64_OpOrB(v *Value) bool {
+func rewriteValueMIPS64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueMIPS64_OpRound32F(v *Value) bool {
+func rewriteValueMIPS64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpRound64F(v *Value) bool {
+func rewriteValueMIPS64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh16x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh32x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh64x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8x16(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8x32(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8x64(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpRsh8x8(v *Value) bool {
+func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueMIPS64_OpSelect0(v *Value) bool {
+func rewriteValueMIPS64_OpSelect0_0(v *Value) bool {
// match: (Select0 (DIVVU _ (MOVVconst [1])))
// cond:
// result: (MOVVconst [0])
}
return false
}
-func rewriteValueMIPS64_OpSelect1(v *Value) bool {
+func rewriteValueMIPS64_OpSelect1_0(v *Value) bool {
// match: (Select1 (MULVU x (MOVVconst [-1])))
// cond:
// result: (NEGV x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpSelect1_10(v *Value) bool {
// match: (Select1 (MULVU (MOVVconst [0]) _))
// cond:
// result: (MOVVconst [0])
v.AuxInt = c * d
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpSelect1_20(v *Value) bool {
// match: (Select1 (DIVV (MOVVconst [c]) (MOVVconst [d])))
// cond:
// result: (MOVVconst [int64(c)/int64(d)])
}
return false
}
-func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueMIPS64_OpSlicemask(v *Value) bool {
+func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueMIPS64_OpStaticCall(v *Value) bool {
+func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueMIPS64_OpStore(v *Value) bool {
+func rewriteValueMIPS64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 1
// result: (MOVBstore ptr val mem)
}
return false
}
-func rewriteValueMIPS64_OpSub16(v *Value) bool {
+func rewriteValueMIPS64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBV x y)
return true
}
}
-func rewriteValueMIPS64_OpSub32(v *Value) bool {
+func rewriteValueMIPS64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBV x y)
return true
}
}
-func rewriteValueMIPS64_OpSub32F(v *Value) bool {
+func rewriteValueMIPS64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (SUBF x y)
return true
}
}
-func rewriteValueMIPS64_OpSub64(v *Value) bool {
+func rewriteValueMIPS64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUBV x y)
return true
}
}
-func rewriteValueMIPS64_OpSub64F(v *Value) bool {
+func rewriteValueMIPS64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (SUBD x y)
return true
}
}
-func rewriteValueMIPS64_OpSub8(v *Value) bool {
+func rewriteValueMIPS64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBV x y)
return true
}
}
-func rewriteValueMIPS64_OpSubPtr(v *Value) bool {
+func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUBV x y)
return true
}
}
-func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool {
+func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueMIPS64_OpXor16(v *Value) bool {
+func rewriteValueMIPS64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS64_OpXor32(v *Value) bool {
+func rewriteValueMIPS64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS64_OpXor64(v *Value) bool {
+func rewriteValueMIPS64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS64_OpXor8(v *Value) bool {
+func rewriteValueMIPS64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueMIPS64_OpZero(v *Value) bool {
+func rewriteValueMIPS64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
- config := b.Func.Config
- _ = config
types := &b.Func.Config.Types
_ = types
// match: (Zero [0] _ mem)
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueMIPS64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
+ types := &b.Func.Config.Types
+ _ = types
// match: (Zero [3] ptr mem)
// cond:
// result: (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem)))
}
return false
}
-func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHUreg x)
return true
}
}
-func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWUreg x)
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBUreg x)
return true
}
}
-func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool {
+func rewriteValueMIPS64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBUreg x)
func rewriteValuePPC64(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValuePPC64_OpAdd16(v)
+ return rewriteValuePPC64_OpAdd16_0(v)
case OpAdd32:
- return rewriteValuePPC64_OpAdd32(v)
+ return rewriteValuePPC64_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValuePPC64_OpAdd32F(v)
+ return rewriteValuePPC64_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValuePPC64_OpAdd64(v)
+ return rewriteValuePPC64_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValuePPC64_OpAdd64F(v)
+ return rewriteValuePPC64_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValuePPC64_OpAdd8(v)
+ return rewriteValuePPC64_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValuePPC64_OpAddPtr(v)
+ return rewriteValuePPC64_OpAddPtr_0(v)
case OpAddr:
- return rewriteValuePPC64_OpAddr(v)
+ return rewriteValuePPC64_OpAddr_0(v)
case OpAnd16:
- return rewriteValuePPC64_OpAnd16(v)
+ return rewriteValuePPC64_OpAnd16_0(v)
case OpAnd32:
- return rewriteValuePPC64_OpAnd32(v)
+ return rewriteValuePPC64_OpAnd32_0(v)
case OpAnd64:
- return rewriteValuePPC64_OpAnd64(v)
+ return rewriteValuePPC64_OpAnd64_0(v)
case OpAnd8:
- return rewriteValuePPC64_OpAnd8(v)
+ return rewriteValuePPC64_OpAnd8_0(v)
case OpAndB:
- return rewriteValuePPC64_OpAndB(v)
+ return rewriteValuePPC64_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValuePPC64_OpAtomicAdd32(v)
+ return rewriteValuePPC64_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValuePPC64_OpAtomicAdd64(v)
+ return rewriteValuePPC64_OpAtomicAdd64_0(v)
case OpAtomicAnd8:
- return rewriteValuePPC64_OpAtomicAnd8(v)
+ return rewriteValuePPC64_OpAtomicAnd8_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValuePPC64_OpAtomicCompareAndSwap32(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValuePPC64_OpAtomicCompareAndSwap64(v)
+ return rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValuePPC64_OpAtomicExchange32(v)
+ return rewriteValuePPC64_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValuePPC64_OpAtomicExchange64(v)
+ return rewriteValuePPC64_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValuePPC64_OpAtomicLoad32(v)
+ return rewriteValuePPC64_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValuePPC64_OpAtomicLoad64(v)
+ return rewriteValuePPC64_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValuePPC64_OpAtomicLoadPtr(v)
+ return rewriteValuePPC64_OpAtomicLoadPtr_0(v)
case OpAtomicOr8:
- return rewriteValuePPC64_OpAtomicOr8(v)
+ return rewriteValuePPC64_OpAtomicOr8_0(v)
case OpAtomicStore32:
- return rewriteValuePPC64_OpAtomicStore32(v)
+ return rewriteValuePPC64_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValuePPC64_OpAtomicStore64(v)
+ return rewriteValuePPC64_OpAtomicStore64_0(v)
case OpAvg64u:
- return rewriteValuePPC64_OpAvg64u(v)
+ return rewriteValuePPC64_OpAvg64u_0(v)
case OpClosureCall:
- return rewriteValuePPC64_OpClosureCall(v)
+ return rewriteValuePPC64_OpClosureCall_0(v)
case OpCom16:
- return rewriteValuePPC64_OpCom16(v)
+ return rewriteValuePPC64_OpCom16_0(v)
case OpCom32:
- return rewriteValuePPC64_OpCom32(v)
+ return rewriteValuePPC64_OpCom32_0(v)
case OpCom64:
- return rewriteValuePPC64_OpCom64(v)
+ return rewriteValuePPC64_OpCom64_0(v)
case OpCom8:
- return rewriteValuePPC64_OpCom8(v)
+ return rewriteValuePPC64_OpCom8_0(v)
case OpConst16:
- return rewriteValuePPC64_OpConst16(v)
+ return rewriteValuePPC64_OpConst16_0(v)
case OpConst32:
- return rewriteValuePPC64_OpConst32(v)
+ return rewriteValuePPC64_OpConst32_0(v)
case OpConst32F:
- return rewriteValuePPC64_OpConst32F(v)
+ return rewriteValuePPC64_OpConst32F_0(v)
case OpConst64:
- return rewriteValuePPC64_OpConst64(v)
+ return rewriteValuePPC64_OpConst64_0(v)
case OpConst64F:
- return rewriteValuePPC64_OpConst64F(v)
+ return rewriteValuePPC64_OpConst64F_0(v)
case OpConst8:
- return rewriteValuePPC64_OpConst8(v)
+ return rewriteValuePPC64_OpConst8_0(v)
case OpConstBool:
- return rewriteValuePPC64_OpConstBool(v)
+ return rewriteValuePPC64_OpConstBool_0(v)
case OpConstNil:
- return rewriteValuePPC64_OpConstNil(v)
+ return rewriteValuePPC64_OpConstNil_0(v)
case OpConvert:
- return rewriteValuePPC64_OpConvert(v)
+ return rewriteValuePPC64_OpConvert_0(v)
case OpCvt32Fto32:
- return rewriteValuePPC64_OpCvt32Fto32(v)
+ return rewriteValuePPC64_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValuePPC64_OpCvt32Fto64(v)
+ return rewriteValuePPC64_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValuePPC64_OpCvt32Fto64F(v)
+ return rewriteValuePPC64_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValuePPC64_OpCvt32to32F(v)
+ return rewriteValuePPC64_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValuePPC64_OpCvt32to64F(v)
+ return rewriteValuePPC64_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValuePPC64_OpCvt64Fto32(v)
+ return rewriteValuePPC64_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValuePPC64_OpCvt64Fto32F(v)
+ return rewriteValuePPC64_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValuePPC64_OpCvt64Fto64(v)
+ return rewriteValuePPC64_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValuePPC64_OpCvt64to32F(v)
+ return rewriteValuePPC64_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValuePPC64_OpCvt64to64F(v)
+ return rewriteValuePPC64_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValuePPC64_OpDiv16(v)
+ return rewriteValuePPC64_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValuePPC64_OpDiv16u(v)
+ return rewriteValuePPC64_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValuePPC64_OpDiv32(v)
+ return rewriteValuePPC64_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValuePPC64_OpDiv32F(v)
+ return rewriteValuePPC64_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValuePPC64_OpDiv32u(v)
+ return rewriteValuePPC64_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValuePPC64_OpDiv64(v)
+ return rewriteValuePPC64_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValuePPC64_OpDiv64F(v)
+ return rewriteValuePPC64_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValuePPC64_OpDiv64u(v)
+ return rewriteValuePPC64_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValuePPC64_OpDiv8(v)
+ return rewriteValuePPC64_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValuePPC64_OpDiv8u(v)
+ return rewriteValuePPC64_OpDiv8u_0(v)
case OpEq16:
- return rewriteValuePPC64_OpEq16(v)
+ return rewriteValuePPC64_OpEq16_0(v)
case OpEq32:
- return rewriteValuePPC64_OpEq32(v)
+ return rewriteValuePPC64_OpEq32_0(v)
case OpEq32F:
- return rewriteValuePPC64_OpEq32F(v)
+ return rewriteValuePPC64_OpEq32F_0(v)
case OpEq64:
- return rewriteValuePPC64_OpEq64(v)
+ return rewriteValuePPC64_OpEq64_0(v)
case OpEq64F:
- return rewriteValuePPC64_OpEq64F(v)
+ return rewriteValuePPC64_OpEq64F_0(v)
case OpEq8:
- return rewriteValuePPC64_OpEq8(v)
+ return rewriteValuePPC64_OpEq8_0(v)
case OpEqB:
- return rewriteValuePPC64_OpEqB(v)
+ return rewriteValuePPC64_OpEqB_0(v)
case OpEqPtr:
- return rewriteValuePPC64_OpEqPtr(v)
+ return rewriteValuePPC64_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValuePPC64_OpGeq16(v)
+ return rewriteValuePPC64_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValuePPC64_OpGeq16U(v)
+ return rewriteValuePPC64_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValuePPC64_OpGeq32(v)
+ return rewriteValuePPC64_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValuePPC64_OpGeq32F(v)
+ return rewriteValuePPC64_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValuePPC64_OpGeq32U(v)
+ return rewriteValuePPC64_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValuePPC64_OpGeq64(v)
+ return rewriteValuePPC64_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValuePPC64_OpGeq64F(v)
+ return rewriteValuePPC64_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValuePPC64_OpGeq64U(v)
+ return rewriteValuePPC64_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValuePPC64_OpGeq8(v)
+ return rewriteValuePPC64_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValuePPC64_OpGeq8U(v)
+ return rewriteValuePPC64_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValuePPC64_OpGetClosurePtr(v)
+ return rewriteValuePPC64_OpGetClosurePtr_0(v)
case OpGreater16:
- return rewriteValuePPC64_OpGreater16(v)
+ return rewriteValuePPC64_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValuePPC64_OpGreater16U(v)
+ return rewriteValuePPC64_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValuePPC64_OpGreater32(v)
+ return rewriteValuePPC64_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValuePPC64_OpGreater32F(v)
+ return rewriteValuePPC64_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValuePPC64_OpGreater32U(v)
+ return rewriteValuePPC64_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValuePPC64_OpGreater64(v)
+ return rewriteValuePPC64_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValuePPC64_OpGreater64F(v)
+ return rewriteValuePPC64_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValuePPC64_OpGreater64U(v)
+ return rewriteValuePPC64_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValuePPC64_OpGreater8(v)
+ return rewriteValuePPC64_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValuePPC64_OpGreater8U(v)
+ return rewriteValuePPC64_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValuePPC64_OpHmul32(v)
+ return rewriteValuePPC64_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValuePPC64_OpHmul32u(v)
+ return rewriteValuePPC64_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValuePPC64_OpHmul64(v)
+ return rewriteValuePPC64_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValuePPC64_OpHmul64u(v)
+ return rewriteValuePPC64_OpHmul64u_0(v)
case OpInterCall:
- return rewriteValuePPC64_OpInterCall(v)
+ return rewriteValuePPC64_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValuePPC64_OpIsInBounds(v)
+ return rewriteValuePPC64_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValuePPC64_OpIsNonNil(v)
+ return rewriteValuePPC64_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValuePPC64_OpIsSliceInBounds(v)
+ return rewriteValuePPC64_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValuePPC64_OpLeq16(v)
+ return rewriteValuePPC64_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValuePPC64_OpLeq16U(v)
+ return rewriteValuePPC64_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValuePPC64_OpLeq32(v)
+ return rewriteValuePPC64_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValuePPC64_OpLeq32F(v)
+ return rewriteValuePPC64_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValuePPC64_OpLeq32U(v)
+ return rewriteValuePPC64_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValuePPC64_OpLeq64(v)
+ return rewriteValuePPC64_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValuePPC64_OpLeq64F(v)
+ return rewriteValuePPC64_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValuePPC64_OpLeq64U(v)
+ return rewriteValuePPC64_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValuePPC64_OpLeq8(v)
+ return rewriteValuePPC64_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValuePPC64_OpLeq8U(v)
+ return rewriteValuePPC64_OpLeq8U_0(v)
case OpLess16:
- return rewriteValuePPC64_OpLess16(v)
+ return rewriteValuePPC64_OpLess16_0(v)
case OpLess16U:
- return rewriteValuePPC64_OpLess16U(v)
+ return rewriteValuePPC64_OpLess16U_0(v)
case OpLess32:
- return rewriteValuePPC64_OpLess32(v)
+ return rewriteValuePPC64_OpLess32_0(v)
case OpLess32F:
- return rewriteValuePPC64_OpLess32F(v)
+ return rewriteValuePPC64_OpLess32F_0(v)
case OpLess32U:
- return rewriteValuePPC64_OpLess32U(v)
+ return rewriteValuePPC64_OpLess32U_0(v)
case OpLess64:
- return rewriteValuePPC64_OpLess64(v)
+ return rewriteValuePPC64_OpLess64_0(v)
case OpLess64F:
- return rewriteValuePPC64_OpLess64F(v)
+ return rewriteValuePPC64_OpLess64F_0(v)
case OpLess64U:
- return rewriteValuePPC64_OpLess64U(v)
+ return rewriteValuePPC64_OpLess64U_0(v)
case OpLess8:
- return rewriteValuePPC64_OpLess8(v)
+ return rewriteValuePPC64_OpLess8_0(v)
case OpLess8U:
- return rewriteValuePPC64_OpLess8U(v)
+ return rewriteValuePPC64_OpLess8U_0(v)
case OpLoad:
- return rewriteValuePPC64_OpLoad(v)
+ return rewriteValuePPC64_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValuePPC64_OpLsh16x16(v)
+ return rewriteValuePPC64_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValuePPC64_OpLsh16x32(v)
+ return rewriteValuePPC64_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValuePPC64_OpLsh16x64(v)
+ return rewriteValuePPC64_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValuePPC64_OpLsh16x8(v)
+ return rewriteValuePPC64_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValuePPC64_OpLsh32x16(v)
+ return rewriteValuePPC64_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValuePPC64_OpLsh32x32(v)
+ return rewriteValuePPC64_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValuePPC64_OpLsh32x64(v)
+ return rewriteValuePPC64_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValuePPC64_OpLsh32x8(v)
+ return rewriteValuePPC64_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValuePPC64_OpLsh64x16(v)
+ return rewriteValuePPC64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValuePPC64_OpLsh64x32(v)
+ return rewriteValuePPC64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValuePPC64_OpLsh64x64(v)
+ return rewriteValuePPC64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValuePPC64_OpLsh64x8(v)
+ return rewriteValuePPC64_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValuePPC64_OpLsh8x16(v)
+ return rewriteValuePPC64_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValuePPC64_OpLsh8x32(v)
+ return rewriteValuePPC64_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValuePPC64_OpLsh8x64(v)
+ return rewriteValuePPC64_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValuePPC64_OpLsh8x8(v)
+ return rewriteValuePPC64_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValuePPC64_OpMod16(v)
+ return rewriteValuePPC64_OpMod16_0(v)
case OpMod16u:
- return rewriteValuePPC64_OpMod16u(v)
+ return rewriteValuePPC64_OpMod16u_0(v)
case OpMod32:
- return rewriteValuePPC64_OpMod32(v)
+ return rewriteValuePPC64_OpMod32_0(v)
case OpMod32u:
- return rewriteValuePPC64_OpMod32u(v)
+ return rewriteValuePPC64_OpMod32u_0(v)
case OpMod64:
- return rewriteValuePPC64_OpMod64(v)
+ return rewriteValuePPC64_OpMod64_0(v)
case OpMod64u:
- return rewriteValuePPC64_OpMod64u(v)
+ return rewriteValuePPC64_OpMod64u_0(v)
case OpMod8:
- return rewriteValuePPC64_OpMod8(v)
+ return rewriteValuePPC64_OpMod8_0(v)
case OpMod8u:
- return rewriteValuePPC64_OpMod8u(v)
+ return rewriteValuePPC64_OpMod8u_0(v)
case OpMove:
- return rewriteValuePPC64_OpMove(v)
+ return rewriteValuePPC64_OpMove_0(v) || rewriteValuePPC64_OpMove_10(v)
case OpMul16:
- return rewriteValuePPC64_OpMul16(v)
+ return rewriteValuePPC64_OpMul16_0(v)
case OpMul32:
- return rewriteValuePPC64_OpMul32(v)
+ return rewriteValuePPC64_OpMul32_0(v)
case OpMul32F:
- return rewriteValuePPC64_OpMul32F(v)
+ return rewriteValuePPC64_OpMul32F_0(v)
case OpMul64:
- return rewriteValuePPC64_OpMul64(v)
+ return rewriteValuePPC64_OpMul64_0(v)
case OpMul64F:
- return rewriteValuePPC64_OpMul64F(v)
+ return rewriteValuePPC64_OpMul64F_0(v)
case OpMul8:
- return rewriteValuePPC64_OpMul8(v)
+ return rewriteValuePPC64_OpMul8_0(v)
case OpNeg16:
- return rewriteValuePPC64_OpNeg16(v)
+ return rewriteValuePPC64_OpNeg16_0(v)
case OpNeg32:
- return rewriteValuePPC64_OpNeg32(v)
+ return rewriteValuePPC64_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValuePPC64_OpNeg32F(v)
+ return rewriteValuePPC64_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValuePPC64_OpNeg64(v)
+ return rewriteValuePPC64_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValuePPC64_OpNeg64F(v)
+ return rewriteValuePPC64_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValuePPC64_OpNeg8(v)
+ return rewriteValuePPC64_OpNeg8_0(v)
case OpNeq16:
- return rewriteValuePPC64_OpNeq16(v)
+ return rewriteValuePPC64_OpNeq16_0(v)
case OpNeq32:
- return rewriteValuePPC64_OpNeq32(v)
+ return rewriteValuePPC64_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValuePPC64_OpNeq32F(v)
+ return rewriteValuePPC64_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValuePPC64_OpNeq64(v)
+ return rewriteValuePPC64_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValuePPC64_OpNeq64F(v)
+ return rewriteValuePPC64_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValuePPC64_OpNeq8(v)
+ return rewriteValuePPC64_OpNeq8_0(v)
case OpNeqB:
- return rewriteValuePPC64_OpNeqB(v)
+ return rewriteValuePPC64_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValuePPC64_OpNeqPtr(v)
+ return rewriteValuePPC64_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValuePPC64_OpNilCheck(v)
+ return rewriteValuePPC64_OpNilCheck_0(v)
case OpNot:
- return rewriteValuePPC64_OpNot(v)
+ return rewriteValuePPC64_OpNot_0(v)
case OpOffPtr:
- return rewriteValuePPC64_OpOffPtr(v)
+ return rewriteValuePPC64_OpOffPtr_0(v)
case OpOr16:
- return rewriteValuePPC64_OpOr16(v)
+ return rewriteValuePPC64_OpOr16_0(v)
case OpOr32:
- return rewriteValuePPC64_OpOr32(v)
+ return rewriteValuePPC64_OpOr32_0(v)
case OpOr64:
- return rewriteValuePPC64_OpOr64(v)
+ return rewriteValuePPC64_OpOr64_0(v)
case OpOr8:
- return rewriteValuePPC64_OpOr8(v)
+ return rewriteValuePPC64_OpOr8_0(v)
case OpOrB:
- return rewriteValuePPC64_OpOrB(v)
+ return rewriteValuePPC64_OpOrB_0(v)
case OpPPC64ADD:
- return rewriteValuePPC64_OpPPC64ADD(v)
+ return rewriteValuePPC64_OpPPC64ADD_0(v)
case OpPPC64ADDconst:
- return rewriteValuePPC64_OpPPC64ADDconst(v)
+ return rewriteValuePPC64_OpPPC64ADDconst_0(v)
case OpPPC64AND:
- return rewriteValuePPC64_OpPPC64AND(v)
+ return rewriteValuePPC64_OpPPC64AND_0(v)
case OpPPC64ANDconst:
- return rewriteValuePPC64_OpPPC64ANDconst(v)
+ return rewriteValuePPC64_OpPPC64ANDconst_0(v)
case OpPPC64CMP:
- return rewriteValuePPC64_OpPPC64CMP(v)
+ return rewriteValuePPC64_OpPPC64CMP_0(v)
case OpPPC64CMPU:
- return rewriteValuePPC64_OpPPC64CMPU(v)
+ return rewriteValuePPC64_OpPPC64CMPU_0(v)
case OpPPC64CMPUconst:
- return rewriteValuePPC64_OpPPC64CMPUconst(v)
+ return rewriteValuePPC64_OpPPC64CMPUconst_0(v)
case OpPPC64CMPW:
- return rewriteValuePPC64_OpPPC64CMPW(v)
+ return rewriteValuePPC64_OpPPC64CMPW_0(v)
case OpPPC64CMPWU:
- return rewriteValuePPC64_OpPPC64CMPWU(v)
+ return rewriteValuePPC64_OpPPC64CMPWU_0(v)
case OpPPC64CMPWUconst:
- return rewriteValuePPC64_OpPPC64CMPWUconst(v)
+ return rewriteValuePPC64_OpPPC64CMPWUconst_0(v)
case OpPPC64CMPWconst:
- return rewriteValuePPC64_OpPPC64CMPWconst(v)
+ return rewriteValuePPC64_OpPPC64CMPWconst_0(v)
case OpPPC64CMPconst:
- return rewriteValuePPC64_OpPPC64CMPconst(v)
+ return rewriteValuePPC64_OpPPC64CMPconst_0(v)
case OpPPC64Equal:
- return rewriteValuePPC64_OpPPC64Equal(v)
+ return rewriteValuePPC64_OpPPC64Equal_0(v)
case OpPPC64FADD:
- return rewriteValuePPC64_OpPPC64FADD(v)
+ return rewriteValuePPC64_OpPPC64FADD_0(v)
case OpPPC64FADDS:
- return rewriteValuePPC64_OpPPC64FADDS(v)
+ return rewriteValuePPC64_OpPPC64FADDS_0(v)
case OpPPC64FMOVDload:
- return rewriteValuePPC64_OpPPC64FMOVDload(v)
+ return rewriteValuePPC64_OpPPC64FMOVDload_0(v)
case OpPPC64FMOVDstore:
- return rewriteValuePPC64_OpPPC64FMOVDstore(v)
+ return rewriteValuePPC64_OpPPC64FMOVDstore_0(v)
case OpPPC64FMOVSload:
- return rewriteValuePPC64_OpPPC64FMOVSload(v)
+ return rewriteValuePPC64_OpPPC64FMOVSload_0(v)
case OpPPC64FMOVSstore:
- return rewriteValuePPC64_OpPPC64FMOVSstore(v)
+ return rewriteValuePPC64_OpPPC64FMOVSstore_0(v)
case OpPPC64FSUB:
- return rewriteValuePPC64_OpPPC64FSUB(v)
+ return rewriteValuePPC64_OpPPC64FSUB_0(v)
case OpPPC64FSUBS:
- return rewriteValuePPC64_OpPPC64FSUBS(v)
+ return rewriteValuePPC64_OpPPC64FSUBS_0(v)
case OpPPC64GreaterEqual:
- return rewriteValuePPC64_OpPPC64GreaterEqual(v)
+ return rewriteValuePPC64_OpPPC64GreaterEqual_0(v)
case OpPPC64GreaterThan:
- return rewriteValuePPC64_OpPPC64GreaterThan(v)
+ return rewriteValuePPC64_OpPPC64GreaterThan_0(v)
case OpPPC64LessEqual:
- return rewriteValuePPC64_OpPPC64LessEqual(v)
+ return rewriteValuePPC64_OpPPC64LessEqual_0(v)
case OpPPC64LessThan:
- return rewriteValuePPC64_OpPPC64LessThan(v)
+ return rewriteValuePPC64_OpPPC64LessThan_0(v)
case OpPPC64MOVBZload:
- return rewriteValuePPC64_OpPPC64MOVBZload(v)
+ return rewriteValuePPC64_OpPPC64MOVBZload_0(v)
case OpPPC64MOVBZreg:
- return rewriteValuePPC64_OpPPC64MOVBZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVBZreg_0(v)
case OpPPC64MOVBreg:
- return rewriteValuePPC64_OpPPC64MOVBreg(v)
+ return rewriteValuePPC64_OpPPC64MOVBreg_0(v)
case OpPPC64MOVBstore:
- return rewriteValuePPC64_OpPPC64MOVBstore(v)
+ return rewriteValuePPC64_OpPPC64MOVBstore_0(v)
case OpPPC64MOVBstorezero:
- return rewriteValuePPC64_OpPPC64MOVBstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVBstorezero_0(v)
case OpPPC64MOVDload:
- return rewriteValuePPC64_OpPPC64MOVDload(v)
+ return rewriteValuePPC64_OpPPC64MOVDload_0(v)
case OpPPC64MOVDstore:
- return rewriteValuePPC64_OpPPC64MOVDstore(v)
+ return rewriteValuePPC64_OpPPC64MOVDstore_0(v)
case OpPPC64MOVDstorezero:
- return rewriteValuePPC64_OpPPC64MOVDstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVDstorezero_0(v)
case OpPPC64MOVHZload:
- return rewriteValuePPC64_OpPPC64MOVHZload(v)
+ return rewriteValuePPC64_OpPPC64MOVHZload_0(v)
case OpPPC64MOVHZreg:
- return rewriteValuePPC64_OpPPC64MOVHZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVHZreg_0(v)
case OpPPC64MOVHload:
- return rewriteValuePPC64_OpPPC64MOVHload(v)
+ return rewriteValuePPC64_OpPPC64MOVHload_0(v)
case OpPPC64MOVHreg:
- return rewriteValuePPC64_OpPPC64MOVHreg(v)
+ return rewriteValuePPC64_OpPPC64MOVHreg_0(v)
case OpPPC64MOVHstore:
- return rewriteValuePPC64_OpPPC64MOVHstore(v)
+ return rewriteValuePPC64_OpPPC64MOVHstore_0(v)
case OpPPC64MOVHstorezero:
- return rewriteValuePPC64_OpPPC64MOVHstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVHstorezero_0(v)
case OpPPC64MOVWZload:
- return rewriteValuePPC64_OpPPC64MOVWZload(v)
+ return rewriteValuePPC64_OpPPC64MOVWZload_0(v)
case OpPPC64MOVWZreg:
- return rewriteValuePPC64_OpPPC64MOVWZreg(v)
+ return rewriteValuePPC64_OpPPC64MOVWZreg_0(v)
case OpPPC64MOVWload:
- return rewriteValuePPC64_OpPPC64MOVWload(v)
+ return rewriteValuePPC64_OpPPC64MOVWload_0(v)
case OpPPC64MOVWreg:
- return rewriteValuePPC64_OpPPC64MOVWreg(v)
+ return rewriteValuePPC64_OpPPC64MOVWreg_0(v)
case OpPPC64MOVWstore:
- return rewriteValuePPC64_OpPPC64MOVWstore(v)
+ return rewriteValuePPC64_OpPPC64MOVWstore_0(v)
case OpPPC64MOVWstorezero:
- return rewriteValuePPC64_OpPPC64MOVWstorezero(v)
+ return rewriteValuePPC64_OpPPC64MOVWstorezero_0(v)
case OpPPC64MaskIfNotCarry:
- return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v)
+ return rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v)
case OpPPC64NotEqual:
- return rewriteValuePPC64_OpPPC64NotEqual(v)
+ return rewriteValuePPC64_OpPPC64NotEqual_0(v)
case OpPPC64OR:
- return rewriteValuePPC64_OpPPC64OR(v)
+ return rewriteValuePPC64_OpPPC64OR_0(v)
case OpPPC64ORN:
- return rewriteValuePPC64_OpPPC64ORN(v)
+ return rewriteValuePPC64_OpPPC64ORN_0(v)
case OpPPC64ORconst:
- return rewriteValuePPC64_OpPPC64ORconst(v)
+ return rewriteValuePPC64_OpPPC64ORconst_0(v)
case OpPPC64SUB:
- return rewriteValuePPC64_OpPPC64SUB(v)
+ return rewriteValuePPC64_OpPPC64SUB_0(v)
case OpPPC64XOR:
- return rewriteValuePPC64_OpPPC64XOR(v)
+ return rewriteValuePPC64_OpPPC64XOR_0(v)
case OpPPC64XORconst:
- return rewriteValuePPC64_OpPPC64XORconst(v)
+ return rewriteValuePPC64_OpPPC64XORconst_0(v)
case OpRound32F:
- return rewriteValuePPC64_OpRound32F(v)
+ return rewriteValuePPC64_OpRound32F_0(v)
case OpRound64F:
- return rewriteValuePPC64_OpRound64F(v)
+ return rewriteValuePPC64_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValuePPC64_OpRsh16Ux16(v)
+ return rewriteValuePPC64_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValuePPC64_OpRsh16Ux32(v)
+ return rewriteValuePPC64_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValuePPC64_OpRsh16Ux64(v)
+ return rewriteValuePPC64_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValuePPC64_OpRsh16Ux8(v)
+ return rewriteValuePPC64_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValuePPC64_OpRsh16x16(v)
+ return rewriteValuePPC64_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValuePPC64_OpRsh16x32(v)
+ return rewriteValuePPC64_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValuePPC64_OpRsh16x64(v)
+ return rewriteValuePPC64_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValuePPC64_OpRsh16x8(v)
+ return rewriteValuePPC64_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValuePPC64_OpRsh32Ux16(v)
+ return rewriteValuePPC64_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValuePPC64_OpRsh32Ux32(v)
+ return rewriteValuePPC64_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValuePPC64_OpRsh32Ux64(v)
+ return rewriteValuePPC64_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValuePPC64_OpRsh32Ux8(v)
+ return rewriteValuePPC64_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValuePPC64_OpRsh32x16(v)
+ return rewriteValuePPC64_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValuePPC64_OpRsh32x32(v)
+ return rewriteValuePPC64_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValuePPC64_OpRsh32x64(v)
+ return rewriteValuePPC64_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValuePPC64_OpRsh32x8(v)
+ return rewriteValuePPC64_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValuePPC64_OpRsh64Ux16(v)
+ return rewriteValuePPC64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValuePPC64_OpRsh64Ux32(v)
+ return rewriteValuePPC64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValuePPC64_OpRsh64Ux64(v)
+ return rewriteValuePPC64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValuePPC64_OpRsh64Ux8(v)
+ return rewriteValuePPC64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValuePPC64_OpRsh64x16(v)
+ return rewriteValuePPC64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValuePPC64_OpRsh64x32(v)
+ return rewriteValuePPC64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValuePPC64_OpRsh64x64(v)
+ return rewriteValuePPC64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValuePPC64_OpRsh64x8(v)
+ return rewriteValuePPC64_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValuePPC64_OpRsh8Ux16(v)
+ return rewriteValuePPC64_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValuePPC64_OpRsh8Ux32(v)
+ return rewriteValuePPC64_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValuePPC64_OpRsh8Ux64(v)
+ return rewriteValuePPC64_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValuePPC64_OpRsh8Ux8(v)
+ return rewriteValuePPC64_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValuePPC64_OpRsh8x16(v)
+ return rewriteValuePPC64_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValuePPC64_OpRsh8x32(v)
+ return rewriteValuePPC64_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValuePPC64_OpRsh8x64(v)
+ return rewriteValuePPC64_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValuePPC64_OpRsh8x8(v)
+ return rewriteValuePPC64_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValuePPC64_OpSignExt16to32(v)
+ return rewriteValuePPC64_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValuePPC64_OpSignExt16to64(v)
+ return rewriteValuePPC64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValuePPC64_OpSignExt32to64(v)
+ return rewriteValuePPC64_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValuePPC64_OpSignExt8to16(v)
+ return rewriteValuePPC64_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValuePPC64_OpSignExt8to32(v)
+ return rewriteValuePPC64_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValuePPC64_OpSignExt8to64(v)
+ return rewriteValuePPC64_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValuePPC64_OpSlicemask(v)
+ return rewriteValuePPC64_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValuePPC64_OpSqrt(v)
+ return rewriteValuePPC64_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValuePPC64_OpStaticCall(v)
+ return rewriteValuePPC64_OpStaticCall_0(v)
case OpStore:
- return rewriteValuePPC64_OpStore(v)
+ return rewriteValuePPC64_OpStore_0(v)
case OpSub16:
- return rewriteValuePPC64_OpSub16(v)
+ return rewriteValuePPC64_OpSub16_0(v)
case OpSub32:
- return rewriteValuePPC64_OpSub32(v)
+ return rewriteValuePPC64_OpSub32_0(v)
case OpSub32F:
- return rewriteValuePPC64_OpSub32F(v)
+ return rewriteValuePPC64_OpSub32F_0(v)
case OpSub64:
- return rewriteValuePPC64_OpSub64(v)
+ return rewriteValuePPC64_OpSub64_0(v)
case OpSub64F:
- return rewriteValuePPC64_OpSub64F(v)
+ return rewriteValuePPC64_OpSub64F_0(v)
case OpSub8:
- return rewriteValuePPC64_OpSub8(v)
+ return rewriteValuePPC64_OpSub8_0(v)
case OpSubPtr:
- return rewriteValuePPC64_OpSubPtr(v)
+ return rewriteValuePPC64_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValuePPC64_OpTrunc16to8(v)
+ return rewriteValuePPC64_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValuePPC64_OpTrunc32to16(v)
+ return rewriteValuePPC64_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValuePPC64_OpTrunc32to8(v)
+ return rewriteValuePPC64_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValuePPC64_OpTrunc64to16(v)
+ return rewriteValuePPC64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValuePPC64_OpTrunc64to32(v)
+ return rewriteValuePPC64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValuePPC64_OpTrunc64to8(v)
+ return rewriteValuePPC64_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValuePPC64_OpXor16(v)
+ return rewriteValuePPC64_OpXor16_0(v)
case OpXor32:
- return rewriteValuePPC64_OpXor32(v)
+ return rewriteValuePPC64_OpXor32_0(v)
case OpXor64:
- return rewriteValuePPC64_OpXor64(v)
+ return rewriteValuePPC64_OpXor64_0(v)
case OpXor8:
- return rewriteValuePPC64_OpXor8(v)
+ return rewriteValuePPC64_OpXor8_0(v)
case OpZero:
- return rewriteValuePPC64_OpZero(v)
+ return rewriteValuePPC64_OpZero_0(v) || rewriteValuePPC64_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValuePPC64_OpZeroExt16to32(v)
+ return rewriteValuePPC64_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValuePPC64_OpZeroExt16to64(v)
+ return rewriteValuePPC64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValuePPC64_OpZeroExt32to64(v)
+ return rewriteValuePPC64_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValuePPC64_OpZeroExt8to16(v)
+ return rewriteValuePPC64_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValuePPC64_OpZeroExt8to32(v)
+ return rewriteValuePPC64_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValuePPC64_OpZeroExt8to64(v)
+ return rewriteValuePPC64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValuePPC64_OpAdd16(v *Value) bool {
+func rewriteValuePPC64_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValuePPC64_OpAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValuePPC64_OpAdd32F(v *Value) bool {
+func rewriteValuePPC64_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
return true
}
}
-func rewriteValuePPC64_OpAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValuePPC64_OpAdd64F(v *Value) bool {
+func rewriteValuePPC64_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADD x y)
return true
}
}
-func rewriteValuePPC64_OpAdd8(v *Value) bool {
+func rewriteValuePPC64_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValuePPC64_OpAddPtr(v *Value) bool {
+func rewriteValuePPC64_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValuePPC64_OpAddr(v *Value) bool {
+func rewriteValuePPC64_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
return true
}
}
-func rewriteValuePPC64_OpAnd16(v *Value) bool {
+func rewriteValuePPC64_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValuePPC64_OpAnd32(v *Value) bool {
+func rewriteValuePPC64_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValuePPC64_OpAnd64(v *Value) bool {
+func rewriteValuePPC64_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValuePPC64_OpAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValuePPC64_OpAndB(v *Value) bool {
+func rewriteValuePPC64_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool {
// match: (AtomicAdd32 ptr val mem)
// cond:
// result: (LoweredAtomicAdd32 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool {
// match: (AtomicAdd64 ptr val mem)
// cond:
// result: (LoweredAtomicAdd64 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool {
// match: (AtomicAnd8 ptr val mem)
// cond:
// result: (LoweredAtomicAnd8 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (LoweredAtomicLoad32 ptr mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (LoweredAtomicLoad64 ptr mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (LoweredAtomicLoadPtr ptr mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicOr8(v *Value) bool {
+func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool {
// match: (AtomicOr8 ptr val mem)
// cond:
// result: (LoweredAtomicOr8 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicStore32(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (LoweredAtomicStore32 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAtomicStore64(v *Value) bool {
+func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (LoweredAtomicStore64 ptr val mem)
return true
}
}
-func rewriteValuePPC64_OpAvg64u(v *Value) bool {
+func rewriteValuePPC64_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
return true
}
}
-func rewriteValuePPC64_OpClosureCall(v *Value) bool {
+func rewriteValuePPC64_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValuePPC64_OpCom16(v *Value) bool {
+func rewriteValuePPC64_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOR x x)
return true
}
}
-func rewriteValuePPC64_OpCom32(v *Value) bool {
+func rewriteValuePPC64_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOR x x)
return true
}
}
-func rewriteValuePPC64_OpCom64(v *Value) bool {
+func rewriteValuePPC64_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOR x x)
return true
}
}
-func rewriteValuePPC64_OpCom8(v *Value) bool {
+func rewriteValuePPC64_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOR x x)
return true
}
}
-func rewriteValuePPC64_OpConst16(v *Value) bool {
+func rewriteValuePPC64_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValuePPC64_OpConst32(v *Value) bool {
+func rewriteValuePPC64_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValuePPC64_OpConst32F(v *Value) bool {
+func rewriteValuePPC64_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
return true
}
}
-func rewriteValuePPC64_OpConst64(v *Value) bool {
+func rewriteValuePPC64_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValuePPC64_OpConst64F(v *Value) bool {
+func rewriteValuePPC64_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
return true
}
}
-func rewriteValuePPC64_OpConst8(v *Value) bool {
+func rewriteValuePPC64_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValuePPC64_OpConstBool(v *Value) bool {
+func rewriteValuePPC64_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
return true
}
}
-func rewriteValuePPC64_OpConstNil(v *Value) bool {
+func rewriteValuePPC64_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
return true
}
}
-func rewriteValuePPC64_OpConvert(v *Value) bool {
+func rewriteValuePPC64_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVDconvert <t> x mem)
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: x
return true
}
}
-func rewriteValuePPC64_OpCvt32to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt32to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (FRSP x)
return true
}
}
-func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool {
+func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt64to32F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpCvt64to64F(v *Value) bool {
+func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpDiv16(v *Value) bool {
+func rewriteValuePPC64_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpDiv16u(v *Value) bool {
+func rewriteValuePPC64_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpDiv32(v *Value) bool {
+func rewriteValuePPC64_OpDiv32_0(v *Value) bool {
// match: (Div32 x y)
// cond:
// result: (DIVW x y)
return true
}
}
-func rewriteValuePPC64_OpDiv32F(v *Value) bool {
+func rewriteValuePPC64_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
return true
}
}
-func rewriteValuePPC64_OpDiv32u(v *Value) bool {
+func rewriteValuePPC64_OpDiv32u_0(v *Value) bool {
// match: (Div32u x y)
// cond:
// result: (DIVWU x y)
return true
}
}
-func rewriteValuePPC64_OpDiv64(v *Value) bool {
+func rewriteValuePPC64_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIVD x y)
return true
}
}
-func rewriteValuePPC64_OpDiv64F(v *Value) bool {
+func rewriteValuePPC64_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIV x y)
return true
}
}
-func rewriteValuePPC64_OpDiv64u(v *Value) bool {
+func rewriteValuePPC64_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (DIVDU x y)
return true
}
}
-func rewriteValuePPC64_OpDiv8(v *Value) bool {
+func rewriteValuePPC64_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpDiv8u(v *Value) bool {
+func rewriteValuePPC64_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpEq16(v *Value) bool {
+func rewriteValuePPC64_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpEq32(v *Value) bool {
+func rewriteValuePPC64_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x y)
return true
}
}
-func rewriteValuePPC64_OpEq32F(v *Value) bool {
+func rewriteValuePPC64_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32F x y)
return true
}
}
-func rewriteValuePPC64_OpEq64(v *Value) bool {
+func rewriteValuePPC64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x y)
return true
}
}
-func rewriteValuePPC64_OpEq64F(v *Value) bool {
+func rewriteValuePPC64_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64F x y)
return true
}
}
-func rewriteValuePPC64_OpEq8(v *Value) bool {
+func rewriteValuePPC64_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpEqB(v *Value) bool {
+func rewriteValuePPC64_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpEqPtr(v *Value) bool {
+func rewriteValuePPC64_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (EqPtr x y)
return true
}
}
-func rewriteValuePPC64_OpGeq16(v *Value) bool {
+func rewriteValuePPC64_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGeq16U(v *Value) bool {
+func rewriteValuePPC64_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGeq32(v *Value) bool {
+func rewriteValuePPC64_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32 x y)
return true
}
}
-func rewriteValuePPC64_OpGeq32F(v *Value) bool {
+func rewriteValuePPC64_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32F x y)
return true
}
}
-func rewriteValuePPC64_OpGeq32U(v *Value) bool {
+func rewriteValuePPC64_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq32U x y)
return true
}
}
-func rewriteValuePPC64_OpGeq64(v *Value) bool {
+func rewriteValuePPC64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64 x y)
return true
}
}
-func rewriteValuePPC64_OpGeq64F(v *Value) bool {
+func rewriteValuePPC64_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64F x y)
return true
}
}
-func rewriteValuePPC64_OpGeq64U(v *Value) bool {
+func rewriteValuePPC64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Geq64U x y)
return true
}
}
-func rewriteValuePPC64_OpGeq8(v *Value) bool {
+func rewriteValuePPC64_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGeq8U(v *Value) bool {
+func rewriteValuePPC64_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool {
+func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValuePPC64_OpGreater16(v *Value) bool {
+func rewriteValuePPC64_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGreater16U(v *Value) bool {
+func rewriteValuePPC64_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGreater32(v *Value) bool {
+func rewriteValuePPC64_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32 x y)
return true
}
}
-func rewriteValuePPC64_OpGreater32F(v *Value) bool {
+func rewriteValuePPC64_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32F x y)
return true
}
}
-func rewriteValuePPC64_OpGreater32U(v *Value) bool {
+func rewriteValuePPC64_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater32U x y)
return true
}
}
-func rewriteValuePPC64_OpGreater64(v *Value) bool {
+func rewriteValuePPC64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64 x y)
return true
}
}
-func rewriteValuePPC64_OpGreater64F(v *Value) bool {
+func rewriteValuePPC64_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64F x y)
return true
}
}
-func rewriteValuePPC64_OpGreater64U(v *Value) bool {
+func rewriteValuePPC64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Greater64U x y)
return true
}
}
-func rewriteValuePPC64_OpGreater8(v *Value) bool {
+func rewriteValuePPC64_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpGreater8U(v *Value) bool {
+func rewriteValuePPC64_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpHmul32(v *Value) bool {
+func rewriteValuePPC64_OpHmul32_0(v *Value) bool {
// match: (Hmul32 x y)
// cond:
// result: (MULHW x y)
return true
}
}
-func rewriteValuePPC64_OpHmul32u(v *Value) bool {
+func rewriteValuePPC64_OpHmul32u_0(v *Value) bool {
// match: (Hmul32u x y)
// cond:
// result: (MULHWU x y)
return true
}
}
-func rewriteValuePPC64_OpHmul64(v *Value) bool {
+func rewriteValuePPC64_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULHD x y)
return true
}
}
-func rewriteValuePPC64_OpHmul64u(v *Value) bool {
+func rewriteValuePPC64_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (MULHDU x y)
return true
}
}
-func rewriteValuePPC64_OpInterCall(v *Value) bool {
+func rewriteValuePPC64_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValuePPC64_OpIsInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsInBounds idx len)
return true
}
}
-func rewriteValuePPC64_OpIsNonNil(v *Value) bool {
+func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsNonNil ptr)
return true
}
}
-func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool {
+func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
// match: (IsSliceInBounds idx len)
return true
}
}
-func rewriteValuePPC64_OpLeq16(v *Value) bool {
+func rewriteValuePPC64_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLeq16U(v *Value) bool {
+func rewriteValuePPC64_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLeq32(v *Value) bool {
+func rewriteValuePPC64_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32 x y)
return true
}
}
-func rewriteValuePPC64_OpLeq32F(v *Value) bool {
+func rewriteValuePPC64_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32F x y)
return true
}
}
-func rewriteValuePPC64_OpLeq32U(v *Value) bool {
+func rewriteValuePPC64_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq32U x y)
return true
}
}
-func rewriteValuePPC64_OpLeq64(v *Value) bool {
+func rewriteValuePPC64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64 x y)
return true
}
}
-func rewriteValuePPC64_OpLeq64F(v *Value) bool {
+func rewriteValuePPC64_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64F x y)
return true
}
}
-func rewriteValuePPC64_OpLeq64U(v *Value) bool {
+func rewriteValuePPC64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Leq64U x y)
return true
}
}
-func rewriteValuePPC64_OpLeq8(v *Value) bool {
+func rewriteValuePPC64_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLeq8U(v *Value) bool {
+func rewriteValuePPC64_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLess16(v *Value) bool {
+func rewriteValuePPC64_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLess16U(v *Value) bool {
+func rewriteValuePPC64_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLess32(v *Value) bool {
+func rewriteValuePPC64_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32 x y)
return true
}
}
-func rewriteValuePPC64_OpLess32F(v *Value) bool {
+func rewriteValuePPC64_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32F x y)
return true
}
}
-func rewriteValuePPC64_OpLess32U(v *Value) bool {
+func rewriteValuePPC64_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less32U x y)
return true
}
}
-func rewriteValuePPC64_OpLess64(v *Value) bool {
+func rewriteValuePPC64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64 x y)
return true
}
}
-func rewriteValuePPC64_OpLess64F(v *Value) bool {
+func rewriteValuePPC64_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64F x y)
return true
}
}
-func rewriteValuePPC64_OpLess64U(v *Value) bool {
+func rewriteValuePPC64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
// match: (Less64U x y)
return true
}
}
-func rewriteValuePPC64_OpLess8(v *Value) bool {
+func rewriteValuePPC64_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLess8U(v *Value) bool {
+func rewriteValuePPC64_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLoad(v *Value) bool {
+func rewriteValuePPC64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuePPC64_OpLsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpLsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod16(v *Value) bool {
+func rewriteValuePPC64_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod16u(v *Value) bool {
+func rewriteValuePPC64_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod32(v *Value) bool {
+func rewriteValuePPC64_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod32u(v *Value) bool {
+func rewriteValuePPC64_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod64(v *Value) bool {
+func rewriteValuePPC64_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod64u(v *Value) bool {
+func rewriteValuePPC64_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod8(v *Value) bool {
+func rewriteValuePPC64_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMod8u(v *Value) bool {
+func rewriteValuePPC64_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpMove(v *Value) bool {
+func rewriteValuePPC64_OpMove_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValuePPC64_OpMove_10(v *Value) bool {
// match: (Move [s] dst src mem)
// cond: s > 8
// result: (LoweredMove [s] dst src mem)
}
return false
}
-func rewriteValuePPC64_OpMul16(v *Value) bool {
+func rewriteValuePPC64_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValuePPC64_OpMul32(v *Value) bool {
+func rewriteValuePPC64_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValuePPC64_OpMul32F(v *Value) bool {
+func rewriteValuePPC64_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
return true
}
}
-func rewriteValuePPC64_OpMul64(v *Value) bool {
+func rewriteValuePPC64_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULLD x y)
return true
}
}
-func rewriteValuePPC64_OpMul64F(v *Value) bool {
+func rewriteValuePPC64_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMUL x y)
return true
}
}
-func rewriteValuePPC64_OpMul8(v *Value) bool {
+func rewriteValuePPC64_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValuePPC64_OpNeg16(v *Value) bool {
+func rewriteValuePPC64_OpNeg16_0(v *Value) bool {
// match: (Neg16 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValuePPC64_OpNeg32(v *Value) bool {
+func rewriteValuePPC64_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValuePPC64_OpNeg32F(v *Value) bool {
+func rewriteValuePPC64_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEG x)
return true
}
}
-func rewriteValuePPC64_OpNeg64(v *Value) bool {
+func rewriteValuePPC64_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValuePPC64_OpNeg64F(v *Value) bool {
+func rewriteValuePPC64_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEG x)
return true
}
}
-func rewriteValuePPC64_OpNeg8(v *Value) bool {
+func rewriteValuePPC64_OpNeg8_0(v *Value) bool {
// match: (Neg8 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValuePPC64_OpNeq16(v *Value) bool {
+func rewriteValuePPC64_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpNeq32(v *Value) bool {
+func rewriteValuePPC64_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x y)
return true
}
}
-func rewriteValuePPC64_OpNeq32F(v *Value) bool {
+func rewriteValuePPC64_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32F x y)
return true
}
}
-func rewriteValuePPC64_OpNeq64(v *Value) bool {
+func rewriteValuePPC64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x y)
return true
}
}
-func rewriteValuePPC64_OpNeq64F(v *Value) bool {
+func rewriteValuePPC64_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64F x y)
return true
}
}
-func rewriteValuePPC64_OpNeq8(v *Value) bool {
+func rewriteValuePPC64_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpNeqB(v *Value) bool {
+func rewriteValuePPC64_OpNeqB_0(v *Value) bool {
// match: (NeqB x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValuePPC64_OpNeqPtr(v *Value) bool {
+func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
// match: (NeqPtr x y)
return true
}
}
-func rewriteValuePPC64_OpNilCheck(v *Value) bool {
+func rewriteValuePPC64_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValuePPC64_OpNot(v *Value) bool {
+func rewriteValuePPC64_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORconst [1] x)
return true
}
}
-func rewriteValuePPC64_OpOffPtr(v *Value) bool {
+func rewriteValuePPC64_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpOr16(v *Value) bool {
+func rewriteValuePPC64_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValuePPC64_OpOr32(v *Value) bool {
+func rewriteValuePPC64_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValuePPC64_OpOr64(v *Value) bool {
+func rewriteValuePPC64_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValuePPC64_OpOr8(v *Value) bool {
+func rewriteValuePPC64_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValuePPC64_OpOrB(v *Value) bool {
+func rewriteValuePPC64_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValuePPC64_OpPPC64ADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool {
// match: (ADD (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool {
// match: (ADDconst [c] (ADDconst [d] x))
// cond: is32Bit(c+d)
// result: (ADDconst [c+d] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64AND(v *Value) bool {
+func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool {
// match: (AND x (NOR y y))
// cond:
// result: (ANDN x y)
}
return false
}
-func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool {
// match: (ANDconst [c] (ANDconst [d] x))
// cond:
// result: (ANDconst [c&d] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64CMP(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPU x (MOVDconst [c]))
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool {
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: int64(x)==int64(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVWreg y))
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPWU x (MOVWZreg y))
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool {
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: int64(x)==int64(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValuePPC64_OpPPC64Equal(v *Value) bool {
+func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool {
// match: (Equal (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValuePPC64_OpPPC64FADD(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool {
// match: (FADD (FMUL x y) z)
// cond:
// result: (FMADD x y z)
}
return false
}
-func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool {
// match: (FADDS (FMULS x y) z)
// cond:
// result: (FMADDS x y z)
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is16Bit(off1+off2)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is16Bit(off1+off2)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool {
// match: (FSUB (FMUL x y) z)
// cond:
// result: (FMSUB x y z)
}
return false
}
-func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool {
+func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool {
// match: (FSUBS (FMULS x y) z)
// cond:
// result: (FMSUBS x y z)
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool {
// match: (GreaterEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool {
// match: (GreaterThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool {
// match: (LessEqual (FlagEQ))
// cond:
// result: (MOVDconst [1])
}
return false
}
-func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool {
+func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool {
// match: (LessThan (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool {
// match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool {
// match: (MOVBZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFF
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool {
// match: (MOVBreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0x7F
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool {
// match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVBstore [off1+off2] {sym} x val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool {
// match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVBstorezero [off1+off2] {sym} x mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool {
// match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} x val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool {
// match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVDstorezero [off1+off2] {sym} x mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool {
// match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool {
// match: (MOVHZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFF
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool {
// match: (MOVHreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0x7FFF
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool {
// match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVHstore [off1+off2] {sym} x val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool {
// match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVHstorezero [off1+off2] {sym} x mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool {
// match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool {
// match: (MOVWZreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFFFFFF
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem)
// cond: canMergeSym(sym1,sym2)
// result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool {
// match: (MOVWreg y:(ANDconst [c] _))
// cond: uint64(c) <= 0xFFFF
// result: y
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool {
// match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem)
// cond: is16Bit(off1+off2)
// result: (MOVWstore [off1+off2] {sym} x val mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool {
// match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem)
// cond: is16Bit(off1+off2)
// result: (MOVWstorezero [off1+off2] {sym} x mem)
}
return false
}
-func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool {
+func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool {
// match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _)))
// cond: c < 0 && d > 0 && c + d < 0
// result: (MOVDconst [-1])
}
return false
}
-func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool {
+func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool {
// match: (NotEqual (FlagEQ))
// cond:
// result: (MOVDconst [0])
}
return false
}
-func rewriteValuePPC64_OpPPC64OR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool {
// match: (OR (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64ORN(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool {
// match: (ORN x (MOVDconst [-1]))
// cond:
// result: x
}
return false
}
-func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool {
// match: (ORconst [c] (ORconst [d] x))
// cond:
// result: (ORconst [c|d] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64SUB(v *Value) bool {
+func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool {
// match: (SUB x (MOVDconst [c]))
// cond: is32Bit(-c)
// result: (ADDconst [-c] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64XOR(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool {
// match: (XOR (SLDconst x [c]) (SRDconst x [d]))
// cond: d == 64-c
// result: (ROTLconst [c] x)
}
return false
}
-func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool {
+func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool {
// match: (XORconst [c] (XORconst [d] x))
// cond:
// result: (XORconst [c^d] x)
}
return false
}
-func rewriteValuePPC64_OpRound32F(v *Value) bool {
+func rewriteValuePPC64_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: (LoweredRound32F x)
return true
}
}
-func rewriteValuePPC64_OpRound64F(v *Value) bool {
+func rewriteValuePPC64_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: (LoweredRound64F x)
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh16x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh32x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh64x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8x16(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8x32(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8x64(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpRsh8x8(v *Value) bool {
+func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuePPC64_OpSignExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValuePPC64_OpSignExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValuePPC64_OpSignExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
return true
}
}
-func rewriteValuePPC64_OpSignExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpSignExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpSignExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpSlicemask(v *Value) bool {
+func rewriteValuePPC64_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValuePPC64_OpSqrt(v *Value) bool {
+func rewriteValuePPC64_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRT x)
return true
}
}
-func rewriteValuePPC64_OpStaticCall(v *Value) bool {
+func rewriteValuePPC64_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValuePPC64_OpStore(v *Value) bool {
+func rewriteValuePPC64_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
}
return false
}
-func rewriteValuePPC64_OpSub16(v *Value) bool {
+func rewriteValuePPC64_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValuePPC64_OpSub32(v *Value) bool {
+func rewriteValuePPC64_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValuePPC64_OpSub32F(v *Value) bool {
+func rewriteValuePPC64_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
return true
}
}
-func rewriteValuePPC64_OpSub64(v *Value) bool {
+func rewriteValuePPC64_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValuePPC64_OpSub64F(v *Value) bool {
+func rewriteValuePPC64_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUB x y)
return true
}
}
-func rewriteValuePPC64_OpSub8(v *Value) bool {
+func rewriteValuePPC64_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValuePPC64_OpSubPtr(v *Value) bool {
+func rewriteValuePPC64_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValuePPC64_OpTrunc16to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpTrunc32to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValuePPC64_OpTrunc32to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpTrunc64to16(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValuePPC64_OpTrunc64to32(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: (MOVWreg x)
return true
}
}
-func rewriteValuePPC64_OpTrunc64to8(v *Value) bool {
+func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValuePPC64_OpXor16(v *Value) bool {
+func rewriteValuePPC64_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValuePPC64_OpXor32(v *Value) bool {
+func rewriteValuePPC64_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValuePPC64_OpXor64(v *Value) bool {
+func rewriteValuePPC64_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValuePPC64_OpXor8(v *Value) bool {
+func rewriteValuePPC64_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValuePPC64_OpZero(v *Value) bool {
+func rewriteValuePPC64_OpZero_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zero [0] _ mem)
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuePPC64_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Zero [16] destptr mem)
// cond:
// result: (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem))
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHZreg x)
return true
}
}
-func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHZreg x)
return true
}
}
-func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWZreg x)
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBZreg x)
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBZreg x)
return true
}
}
-func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuePPC64_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBZreg x)
func rewriteValueS390X(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValueS390X_OpAdd16(v)
+ return rewriteValueS390X_OpAdd16_0(v)
case OpAdd32:
- return rewriteValueS390X_OpAdd32(v)
+ return rewriteValueS390X_OpAdd32_0(v)
case OpAdd32F:
- return rewriteValueS390X_OpAdd32F(v)
+ return rewriteValueS390X_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValueS390X_OpAdd64(v)
+ return rewriteValueS390X_OpAdd64_0(v)
case OpAdd64F:
- return rewriteValueS390X_OpAdd64F(v)
+ return rewriteValueS390X_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValueS390X_OpAdd8(v)
+ return rewriteValueS390X_OpAdd8_0(v)
case OpAddPtr:
- return rewriteValueS390X_OpAddPtr(v)
+ return rewriteValueS390X_OpAddPtr_0(v)
case OpAddr:
- return rewriteValueS390X_OpAddr(v)
+ return rewriteValueS390X_OpAddr_0(v)
case OpAnd16:
- return rewriteValueS390X_OpAnd16(v)
+ return rewriteValueS390X_OpAnd16_0(v)
case OpAnd32:
- return rewriteValueS390X_OpAnd32(v)
+ return rewriteValueS390X_OpAnd32_0(v)
case OpAnd64:
- return rewriteValueS390X_OpAnd64(v)
+ return rewriteValueS390X_OpAnd64_0(v)
case OpAnd8:
- return rewriteValueS390X_OpAnd8(v)
+ return rewriteValueS390X_OpAnd8_0(v)
case OpAndB:
- return rewriteValueS390X_OpAndB(v)
+ return rewriteValueS390X_OpAndB_0(v)
case OpAtomicAdd32:
- return rewriteValueS390X_OpAtomicAdd32(v)
+ return rewriteValueS390X_OpAtomicAdd32_0(v)
case OpAtomicAdd64:
- return rewriteValueS390X_OpAtomicAdd64(v)
+ return rewriteValueS390X_OpAtomicAdd64_0(v)
case OpAtomicCompareAndSwap32:
- return rewriteValueS390X_OpAtomicCompareAndSwap32(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v)
case OpAtomicCompareAndSwap64:
- return rewriteValueS390X_OpAtomicCompareAndSwap64(v)
+ return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v)
case OpAtomicExchange32:
- return rewriteValueS390X_OpAtomicExchange32(v)
+ return rewriteValueS390X_OpAtomicExchange32_0(v)
case OpAtomicExchange64:
- return rewriteValueS390X_OpAtomicExchange64(v)
+ return rewriteValueS390X_OpAtomicExchange64_0(v)
case OpAtomicLoad32:
- return rewriteValueS390X_OpAtomicLoad32(v)
+ return rewriteValueS390X_OpAtomicLoad32_0(v)
case OpAtomicLoad64:
- return rewriteValueS390X_OpAtomicLoad64(v)
+ return rewriteValueS390X_OpAtomicLoad64_0(v)
case OpAtomicLoadPtr:
- return rewriteValueS390X_OpAtomicLoadPtr(v)
+ return rewriteValueS390X_OpAtomicLoadPtr_0(v)
case OpAtomicStore32:
- return rewriteValueS390X_OpAtomicStore32(v)
+ return rewriteValueS390X_OpAtomicStore32_0(v)
case OpAtomicStore64:
- return rewriteValueS390X_OpAtomicStore64(v)
+ return rewriteValueS390X_OpAtomicStore64_0(v)
case OpAtomicStorePtrNoWB:
- return rewriteValueS390X_OpAtomicStorePtrNoWB(v)
+ return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v)
case OpAvg64u:
- return rewriteValueS390X_OpAvg64u(v)
+ return rewriteValueS390X_OpAvg64u_0(v)
case OpBitLen64:
- return rewriteValueS390X_OpBitLen64(v)
+ return rewriteValueS390X_OpBitLen64_0(v)
case OpBswap32:
- return rewriteValueS390X_OpBswap32(v)
+ return rewriteValueS390X_OpBswap32_0(v)
case OpBswap64:
- return rewriteValueS390X_OpBswap64(v)
+ return rewriteValueS390X_OpBswap64_0(v)
case OpClosureCall:
- return rewriteValueS390X_OpClosureCall(v)
+ return rewriteValueS390X_OpClosureCall_0(v)
case OpCom16:
- return rewriteValueS390X_OpCom16(v)
+ return rewriteValueS390X_OpCom16_0(v)
case OpCom32:
- return rewriteValueS390X_OpCom32(v)
+ return rewriteValueS390X_OpCom32_0(v)
case OpCom64:
- return rewriteValueS390X_OpCom64(v)
+ return rewriteValueS390X_OpCom64_0(v)
case OpCom8:
- return rewriteValueS390X_OpCom8(v)
+ return rewriteValueS390X_OpCom8_0(v)
case OpConst16:
- return rewriteValueS390X_OpConst16(v)
+ return rewriteValueS390X_OpConst16_0(v)
case OpConst32:
- return rewriteValueS390X_OpConst32(v)
+ return rewriteValueS390X_OpConst32_0(v)
case OpConst32F:
- return rewriteValueS390X_OpConst32F(v)
+ return rewriteValueS390X_OpConst32F_0(v)
case OpConst64:
- return rewriteValueS390X_OpConst64(v)
+ return rewriteValueS390X_OpConst64_0(v)
case OpConst64F:
- return rewriteValueS390X_OpConst64F(v)
+ return rewriteValueS390X_OpConst64F_0(v)
case OpConst8:
- return rewriteValueS390X_OpConst8(v)
+ return rewriteValueS390X_OpConst8_0(v)
case OpConstBool:
- return rewriteValueS390X_OpConstBool(v)
+ return rewriteValueS390X_OpConstBool_0(v)
case OpConstNil:
- return rewriteValueS390X_OpConstNil(v)
+ return rewriteValueS390X_OpConstNil_0(v)
case OpConvert:
- return rewriteValueS390X_OpConvert(v)
+ return rewriteValueS390X_OpConvert_0(v)
case OpCtz32:
- return rewriteValueS390X_OpCtz32(v)
+ return rewriteValueS390X_OpCtz32_0(v)
case OpCtz64:
- return rewriteValueS390X_OpCtz64(v)
+ return rewriteValueS390X_OpCtz64_0(v)
case OpCvt32Fto32:
- return rewriteValueS390X_OpCvt32Fto32(v)
+ return rewriteValueS390X_OpCvt32Fto32_0(v)
case OpCvt32Fto64:
- return rewriteValueS390X_OpCvt32Fto64(v)
+ return rewriteValueS390X_OpCvt32Fto64_0(v)
case OpCvt32Fto64F:
- return rewriteValueS390X_OpCvt32Fto64F(v)
+ return rewriteValueS390X_OpCvt32Fto64F_0(v)
case OpCvt32to32F:
- return rewriteValueS390X_OpCvt32to32F(v)
+ return rewriteValueS390X_OpCvt32to32F_0(v)
case OpCvt32to64F:
- return rewriteValueS390X_OpCvt32to64F(v)
+ return rewriteValueS390X_OpCvt32to64F_0(v)
case OpCvt64Fto32:
- return rewriteValueS390X_OpCvt64Fto32(v)
+ return rewriteValueS390X_OpCvt64Fto32_0(v)
case OpCvt64Fto32F:
- return rewriteValueS390X_OpCvt64Fto32F(v)
+ return rewriteValueS390X_OpCvt64Fto32F_0(v)
case OpCvt64Fto64:
- return rewriteValueS390X_OpCvt64Fto64(v)
+ return rewriteValueS390X_OpCvt64Fto64_0(v)
case OpCvt64to32F:
- return rewriteValueS390X_OpCvt64to32F(v)
+ return rewriteValueS390X_OpCvt64to32F_0(v)
case OpCvt64to64F:
- return rewriteValueS390X_OpCvt64to64F(v)
+ return rewriteValueS390X_OpCvt64to64F_0(v)
case OpDiv16:
- return rewriteValueS390X_OpDiv16(v)
+ return rewriteValueS390X_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValueS390X_OpDiv16u(v)
+ return rewriteValueS390X_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValueS390X_OpDiv32(v)
+ return rewriteValueS390X_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValueS390X_OpDiv32F(v)
+ return rewriteValueS390X_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValueS390X_OpDiv32u(v)
+ return rewriteValueS390X_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValueS390X_OpDiv64(v)
+ return rewriteValueS390X_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValueS390X_OpDiv64F(v)
+ return rewriteValueS390X_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValueS390X_OpDiv64u(v)
+ return rewriteValueS390X_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValueS390X_OpDiv8(v)
+ return rewriteValueS390X_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValueS390X_OpDiv8u(v)
+ return rewriteValueS390X_OpDiv8u_0(v)
case OpEq16:
- return rewriteValueS390X_OpEq16(v)
+ return rewriteValueS390X_OpEq16_0(v)
case OpEq32:
- return rewriteValueS390X_OpEq32(v)
+ return rewriteValueS390X_OpEq32_0(v)
case OpEq32F:
- return rewriteValueS390X_OpEq32F(v)
+ return rewriteValueS390X_OpEq32F_0(v)
case OpEq64:
- return rewriteValueS390X_OpEq64(v)
+ return rewriteValueS390X_OpEq64_0(v)
case OpEq64F:
- return rewriteValueS390X_OpEq64F(v)
+ return rewriteValueS390X_OpEq64F_0(v)
case OpEq8:
- return rewriteValueS390X_OpEq8(v)
+ return rewriteValueS390X_OpEq8_0(v)
case OpEqB:
- return rewriteValueS390X_OpEqB(v)
+ return rewriteValueS390X_OpEqB_0(v)
case OpEqPtr:
- return rewriteValueS390X_OpEqPtr(v)
+ return rewriteValueS390X_OpEqPtr_0(v)
case OpGeq16:
- return rewriteValueS390X_OpGeq16(v)
+ return rewriteValueS390X_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValueS390X_OpGeq16U(v)
+ return rewriteValueS390X_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValueS390X_OpGeq32(v)
+ return rewriteValueS390X_OpGeq32_0(v)
case OpGeq32F:
- return rewriteValueS390X_OpGeq32F(v)
+ return rewriteValueS390X_OpGeq32F_0(v)
case OpGeq32U:
- return rewriteValueS390X_OpGeq32U(v)
+ return rewriteValueS390X_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValueS390X_OpGeq64(v)
+ return rewriteValueS390X_OpGeq64_0(v)
case OpGeq64F:
- return rewriteValueS390X_OpGeq64F(v)
+ return rewriteValueS390X_OpGeq64F_0(v)
case OpGeq64U:
- return rewriteValueS390X_OpGeq64U(v)
+ return rewriteValueS390X_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValueS390X_OpGeq8(v)
+ return rewriteValueS390X_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValueS390X_OpGeq8U(v)
+ return rewriteValueS390X_OpGeq8U_0(v)
case OpGetClosurePtr:
- return rewriteValueS390X_OpGetClosurePtr(v)
+ return rewriteValueS390X_OpGetClosurePtr_0(v)
case OpGetG:
- return rewriteValueS390X_OpGetG(v)
+ return rewriteValueS390X_OpGetG_0(v)
case OpGreater16:
- return rewriteValueS390X_OpGreater16(v)
+ return rewriteValueS390X_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValueS390X_OpGreater16U(v)
+ return rewriteValueS390X_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValueS390X_OpGreater32(v)
+ return rewriteValueS390X_OpGreater32_0(v)
case OpGreater32F:
- return rewriteValueS390X_OpGreater32F(v)
+ return rewriteValueS390X_OpGreater32F_0(v)
case OpGreater32U:
- return rewriteValueS390X_OpGreater32U(v)
+ return rewriteValueS390X_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValueS390X_OpGreater64(v)
+ return rewriteValueS390X_OpGreater64_0(v)
case OpGreater64F:
- return rewriteValueS390X_OpGreater64F(v)
+ return rewriteValueS390X_OpGreater64F_0(v)
case OpGreater64U:
- return rewriteValueS390X_OpGreater64U(v)
+ return rewriteValueS390X_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValueS390X_OpGreater8(v)
+ return rewriteValueS390X_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValueS390X_OpGreater8U(v)
+ return rewriteValueS390X_OpGreater8U_0(v)
case OpHmul32:
- return rewriteValueS390X_OpHmul32(v)
+ return rewriteValueS390X_OpHmul32_0(v)
case OpHmul32u:
- return rewriteValueS390X_OpHmul32u(v)
+ return rewriteValueS390X_OpHmul32u_0(v)
case OpHmul64:
- return rewriteValueS390X_OpHmul64(v)
+ return rewriteValueS390X_OpHmul64_0(v)
case OpHmul64u:
- return rewriteValueS390X_OpHmul64u(v)
+ return rewriteValueS390X_OpHmul64u_0(v)
case OpITab:
- return rewriteValueS390X_OpITab(v)
+ return rewriteValueS390X_OpITab_0(v)
case OpInterCall:
- return rewriteValueS390X_OpInterCall(v)
+ return rewriteValueS390X_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValueS390X_OpIsInBounds(v)
+ return rewriteValueS390X_OpIsInBounds_0(v)
case OpIsNonNil:
- return rewriteValueS390X_OpIsNonNil(v)
+ return rewriteValueS390X_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValueS390X_OpIsSliceInBounds(v)
+ return rewriteValueS390X_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValueS390X_OpLeq16(v)
+ return rewriteValueS390X_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValueS390X_OpLeq16U(v)
+ return rewriteValueS390X_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValueS390X_OpLeq32(v)
+ return rewriteValueS390X_OpLeq32_0(v)
case OpLeq32F:
- return rewriteValueS390X_OpLeq32F(v)
+ return rewriteValueS390X_OpLeq32F_0(v)
case OpLeq32U:
- return rewriteValueS390X_OpLeq32U(v)
+ return rewriteValueS390X_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValueS390X_OpLeq64(v)
+ return rewriteValueS390X_OpLeq64_0(v)
case OpLeq64F:
- return rewriteValueS390X_OpLeq64F(v)
+ return rewriteValueS390X_OpLeq64F_0(v)
case OpLeq64U:
- return rewriteValueS390X_OpLeq64U(v)
+ return rewriteValueS390X_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValueS390X_OpLeq8(v)
+ return rewriteValueS390X_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValueS390X_OpLeq8U(v)
+ return rewriteValueS390X_OpLeq8U_0(v)
case OpLess16:
- return rewriteValueS390X_OpLess16(v)
+ return rewriteValueS390X_OpLess16_0(v)
case OpLess16U:
- return rewriteValueS390X_OpLess16U(v)
+ return rewriteValueS390X_OpLess16U_0(v)
case OpLess32:
- return rewriteValueS390X_OpLess32(v)
+ return rewriteValueS390X_OpLess32_0(v)
case OpLess32F:
- return rewriteValueS390X_OpLess32F(v)
+ return rewriteValueS390X_OpLess32F_0(v)
case OpLess32U:
- return rewriteValueS390X_OpLess32U(v)
+ return rewriteValueS390X_OpLess32U_0(v)
case OpLess64:
- return rewriteValueS390X_OpLess64(v)
+ return rewriteValueS390X_OpLess64_0(v)
case OpLess64F:
- return rewriteValueS390X_OpLess64F(v)
+ return rewriteValueS390X_OpLess64F_0(v)
case OpLess64U:
- return rewriteValueS390X_OpLess64U(v)
+ return rewriteValueS390X_OpLess64U_0(v)
case OpLess8:
- return rewriteValueS390X_OpLess8(v)
+ return rewriteValueS390X_OpLess8_0(v)
case OpLess8U:
- return rewriteValueS390X_OpLess8U(v)
+ return rewriteValueS390X_OpLess8U_0(v)
case OpLoad:
- return rewriteValueS390X_OpLoad(v)
+ return rewriteValueS390X_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValueS390X_OpLsh16x16(v)
+ return rewriteValueS390X_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValueS390X_OpLsh16x32(v)
+ return rewriteValueS390X_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValueS390X_OpLsh16x64(v)
+ return rewriteValueS390X_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValueS390X_OpLsh16x8(v)
+ return rewriteValueS390X_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValueS390X_OpLsh32x16(v)
+ return rewriteValueS390X_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValueS390X_OpLsh32x32(v)
+ return rewriteValueS390X_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValueS390X_OpLsh32x64(v)
+ return rewriteValueS390X_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValueS390X_OpLsh32x8(v)
+ return rewriteValueS390X_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValueS390X_OpLsh64x16(v)
+ return rewriteValueS390X_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValueS390X_OpLsh64x32(v)
+ return rewriteValueS390X_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValueS390X_OpLsh64x64(v)
+ return rewriteValueS390X_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValueS390X_OpLsh64x8(v)
+ return rewriteValueS390X_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValueS390X_OpLsh8x16(v)
+ return rewriteValueS390X_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValueS390X_OpLsh8x32(v)
+ return rewriteValueS390X_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValueS390X_OpLsh8x64(v)
+ return rewriteValueS390X_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValueS390X_OpLsh8x8(v)
+ return rewriteValueS390X_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValueS390X_OpMod16(v)
+ return rewriteValueS390X_OpMod16_0(v)
case OpMod16u:
- return rewriteValueS390X_OpMod16u(v)
+ return rewriteValueS390X_OpMod16u_0(v)
case OpMod32:
- return rewriteValueS390X_OpMod32(v)
+ return rewriteValueS390X_OpMod32_0(v)
case OpMod32u:
- return rewriteValueS390X_OpMod32u(v)
+ return rewriteValueS390X_OpMod32u_0(v)
case OpMod64:
- return rewriteValueS390X_OpMod64(v)
+ return rewriteValueS390X_OpMod64_0(v)
case OpMod64u:
- return rewriteValueS390X_OpMod64u(v)
+ return rewriteValueS390X_OpMod64u_0(v)
case OpMod8:
- return rewriteValueS390X_OpMod8(v)
+ return rewriteValueS390X_OpMod8_0(v)
case OpMod8u:
- return rewriteValueS390X_OpMod8u(v)
+ return rewriteValueS390X_OpMod8u_0(v)
case OpMove:
- return rewriteValueS390X_OpMove(v)
+ return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v)
case OpMul16:
- return rewriteValueS390X_OpMul16(v)
+ return rewriteValueS390X_OpMul16_0(v)
case OpMul32:
- return rewriteValueS390X_OpMul32(v)
+ return rewriteValueS390X_OpMul32_0(v)
case OpMul32F:
- return rewriteValueS390X_OpMul32F(v)
+ return rewriteValueS390X_OpMul32F_0(v)
case OpMul64:
- return rewriteValueS390X_OpMul64(v)
+ return rewriteValueS390X_OpMul64_0(v)
case OpMul64F:
- return rewriteValueS390X_OpMul64F(v)
+ return rewriteValueS390X_OpMul64F_0(v)
case OpMul8:
- return rewriteValueS390X_OpMul8(v)
+ return rewriteValueS390X_OpMul8_0(v)
case OpNeg16:
- return rewriteValueS390X_OpNeg16(v)
+ return rewriteValueS390X_OpNeg16_0(v)
case OpNeg32:
- return rewriteValueS390X_OpNeg32(v)
+ return rewriteValueS390X_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValueS390X_OpNeg32F(v)
+ return rewriteValueS390X_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValueS390X_OpNeg64(v)
+ return rewriteValueS390X_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValueS390X_OpNeg64F(v)
+ return rewriteValueS390X_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValueS390X_OpNeg8(v)
+ return rewriteValueS390X_OpNeg8_0(v)
case OpNeq16:
- return rewriteValueS390X_OpNeq16(v)
+ return rewriteValueS390X_OpNeq16_0(v)
case OpNeq32:
- return rewriteValueS390X_OpNeq32(v)
+ return rewriteValueS390X_OpNeq32_0(v)
case OpNeq32F:
- return rewriteValueS390X_OpNeq32F(v)
+ return rewriteValueS390X_OpNeq32F_0(v)
case OpNeq64:
- return rewriteValueS390X_OpNeq64(v)
+ return rewriteValueS390X_OpNeq64_0(v)
case OpNeq64F:
- return rewriteValueS390X_OpNeq64F(v)
+ return rewriteValueS390X_OpNeq64F_0(v)
case OpNeq8:
- return rewriteValueS390X_OpNeq8(v)
+ return rewriteValueS390X_OpNeq8_0(v)
case OpNeqB:
- return rewriteValueS390X_OpNeqB(v)
+ return rewriteValueS390X_OpNeqB_0(v)
case OpNeqPtr:
- return rewriteValueS390X_OpNeqPtr(v)
+ return rewriteValueS390X_OpNeqPtr_0(v)
case OpNilCheck:
- return rewriteValueS390X_OpNilCheck(v)
+ return rewriteValueS390X_OpNilCheck_0(v)
case OpNot:
- return rewriteValueS390X_OpNot(v)
+ return rewriteValueS390X_OpNot_0(v)
case OpOffPtr:
- return rewriteValueS390X_OpOffPtr(v)
+ return rewriteValueS390X_OpOffPtr_0(v)
case OpOr16:
- return rewriteValueS390X_OpOr16(v)
+ return rewriteValueS390X_OpOr16_0(v)
case OpOr32:
- return rewriteValueS390X_OpOr32(v)
+ return rewriteValueS390X_OpOr32_0(v)
case OpOr64:
- return rewriteValueS390X_OpOr64(v)
+ return rewriteValueS390X_OpOr64_0(v)
case OpOr8:
- return rewriteValueS390X_OpOr8(v)
+ return rewriteValueS390X_OpOr8_0(v)
case OpOrB:
- return rewriteValueS390X_OpOrB(v)
+ return rewriteValueS390X_OpOrB_0(v)
case OpRound32F:
- return rewriteValueS390X_OpRound32F(v)
+ return rewriteValueS390X_OpRound32F_0(v)
case OpRound64F:
- return rewriteValueS390X_OpRound64F(v)
+ return rewriteValueS390X_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValueS390X_OpRsh16Ux16(v)
+ return rewriteValueS390X_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValueS390X_OpRsh16Ux32(v)
+ return rewriteValueS390X_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValueS390X_OpRsh16Ux64(v)
+ return rewriteValueS390X_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValueS390X_OpRsh16Ux8(v)
+ return rewriteValueS390X_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValueS390X_OpRsh16x16(v)
+ return rewriteValueS390X_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValueS390X_OpRsh16x32(v)
+ return rewriteValueS390X_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValueS390X_OpRsh16x64(v)
+ return rewriteValueS390X_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValueS390X_OpRsh16x8(v)
+ return rewriteValueS390X_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValueS390X_OpRsh32Ux16(v)
+ return rewriteValueS390X_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValueS390X_OpRsh32Ux32(v)
+ return rewriteValueS390X_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValueS390X_OpRsh32Ux64(v)
+ return rewriteValueS390X_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValueS390X_OpRsh32Ux8(v)
+ return rewriteValueS390X_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValueS390X_OpRsh32x16(v)
+ return rewriteValueS390X_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValueS390X_OpRsh32x32(v)
+ return rewriteValueS390X_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValueS390X_OpRsh32x64(v)
+ return rewriteValueS390X_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValueS390X_OpRsh32x8(v)
+ return rewriteValueS390X_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValueS390X_OpRsh64Ux16(v)
+ return rewriteValueS390X_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValueS390X_OpRsh64Ux32(v)
+ return rewriteValueS390X_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValueS390X_OpRsh64Ux64(v)
+ return rewriteValueS390X_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValueS390X_OpRsh64Ux8(v)
+ return rewriteValueS390X_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValueS390X_OpRsh64x16(v)
+ return rewriteValueS390X_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValueS390X_OpRsh64x32(v)
+ return rewriteValueS390X_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValueS390X_OpRsh64x64(v)
+ return rewriteValueS390X_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValueS390X_OpRsh64x8(v)
+ return rewriteValueS390X_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValueS390X_OpRsh8Ux16(v)
+ return rewriteValueS390X_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValueS390X_OpRsh8Ux32(v)
+ return rewriteValueS390X_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValueS390X_OpRsh8Ux64(v)
+ return rewriteValueS390X_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValueS390X_OpRsh8Ux8(v)
+ return rewriteValueS390X_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValueS390X_OpRsh8x16(v)
+ return rewriteValueS390X_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValueS390X_OpRsh8x32(v)
+ return rewriteValueS390X_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValueS390X_OpRsh8x64(v)
+ return rewriteValueS390X_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValueS390X_OpRsh8x8(v)
+ return rewriteValueS390X_OpRsh8x8_0(v)
case OpS390XADD:
- return rewriteValueS390X_OpS390XADD(v)
+ return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v)
case OpS390XADDW:
- return rewriteValueS390X_OpS390XADDW(v)
+ return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v)
case OpS390XADDWconst:
- return rewriteValueS390X_OpS390XADDWconst(v)
+ return rewriteValueS390X_OpS390XADDWconst_0(v)
case OpS390XADDconst:
- return rewriteValueS390X_OpS390XADDconst(v)
+ return rewriteValueS390X_OpS390XADDconst_0(v)
case OpS390XAND:
- return rewriteValueS390X_OpS390XAND(v)
+ return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v)
case OpS390XANDW:
- return rewriteValueS390X_OpS390XANDW(v)
+ return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v)
case OpS390XANDWconst:
- return rewriteValueS390X_OpS390XANDWconst(v)
+ return rewriteValueS390X_OpS390XANDWconst_0(v)
case OpS390XANDconst:
- return rewriteValueS390X_OpS390XANDconst(v)
+ return rewriteValueS390X_OpS390XANDconst_0(v)
case OpS390XCMP:
- return rewriteValueS390X_OpS390XCMP(v)
+ return rewriteValueS390X_OpS390XCMP_0(v)
case OpS390XCMPU:
- return rewriteValueS390X_OpS390XCMPU(v)
+ return rewriteValueS390X_OpS390XCMPU_0(v)
case OpS390XCMPUconst:
- return rewriteValueS390X_OpS390XCMPUconst(v)
+ return rewriteValueS390X_OpS390XCMPUconst_0(v)
case OpS390XCMPW:
- return rewriteValueS390X_OpS390XCMPW(v)
+ return rewriteValueS390X_OpS390XCMPW_0(v)
case OpS390XCMPWU:
- return rewriteValueS390X_OpS390XCMPWU(v)
+ return rewriteValueS390X_OpS390XCMPWU_0(v)
case OpS390XCMPWUconst:
- return rewriteValueS390X_OpS390XCMPWUconst(v)
+ return rewriteValueS390X_OpS390XCMPWUconst_0(v)
case OpS390XCMPWconst:
- return rewriteValueS390X_OpS390XCMPWconst(v)
+ return rewriteValueS390X_OpS390XCMPWconst_0(v)
case OpS390XCMPconst:
- return rewriteValueS390X_OpS390XCMPconst(v)
+ return rewriteValueS390X_OpS390XCMPconst_0(v)
case OpS390XFADD:
- return rewriteValueS390X_OpS390XFADD(v)
+ return rewriteValueS390X_OpS390XFADD_0(v)
case OpS390XFADDS:
- return rewriteValueS390X_OpS390XFADDS(v)
+ return rewriteValueS390X_OpS390XFADDS_0(v)
case OpS390XFMOVDload:
- return rewriteValueS390X_OpS390XFMOVDload(v)
+ return rewriteValueS390X_OpS390XFMOVDload_0(v)
case OpS390XFMOVDloadidx:
- return rewriteValueS390X_OpS390XFMOVDloadidx(v)
+ return rewriteValueS390X_OpS390XFMOVDloadidx_0(v)
case OpS390XFMOVDstore:
- return rewriteValueS390X_OpS390XFMOVDstore(v)
+ return rewriteValueS390X_OpS390XFMOVDstore_0(v)
case OpS390XFMOVDstoreidx:
- return rewriteValueS390X_OpS390XFMOVDstoreidx(v)
+ return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v)
case OpS390XFMOVSload:
- return rewriteValueS390X_OpS390XFMOVSload(v)
+ return rewriteValueS390X_OpS390XFMOVSload_0(v)
case OpS390XFMOVSloadidx:
- return rewriteValueS390X_OpS390XFMOVSloadidx(v)
+ return rewriteValueS390X_OpS390XFMOVSloadidx_0(v)
case OpS390XFMOVSstore:
- return rewriteValueS390X_OpS390XFMOVSstore(v)
+ return rewriteValueS390X_OpS390XFMOVSstore_0(v)
case OpS390XFMOVSstoreidx:
- return rewriteValueS390X_OpS390XFMOVSstoreidx(v)
+ return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v)
case OpS390XFSUB:
- return rewriteValueS390X_OpS390XFSUB(v)
+ return rewriteValueS390X_OpS390XFSUB_0(v)
case OpS390XFSUBS:
- return rewriteValueS390X_OpS390XFSUBS(v)
+ return rewriteValueS390X_OpS390XFSUBS_0(v)
case OpS390XLoweredRound32F:
- return rewriteValueS390X_OpS390XLoweredRound32F(v)
+ return rewriteValueS390X_OpS390XLoweredRound32F_0(v)
case OpS390XLoweredRound64F:
- return rewriteValueS390X_OpS390XLoweredRound64F(v)
+ return rewriteValueS390X_OpS390XLoweredRound64F_0(v)
case OpS390XMOVBZload:
- return rewriteValueS390X_OpS390XMOVBZload(v)
+ return rewriteValueS390X_OpS390XMOVBZload_0(v)
case OpS390XMOVBZloadidx:
- return rewriteValueS390X_OpS390XMOVBZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVBZloadidx_0(v)
case OpS390XMOVBZreg:
- return rewriteValueS390X_OpS390XMOVBZreg(v)
+ return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v)
case OpS390XMOVBload:
- return rewriteValueS390X_OpS390XMOVBload(v)
+ return rewriteValueS390X_OpS390XMOVBload_0(v)
case OpS390XMOVBreg:
- return rewriteValueS390X_OpS390XMOVBreg(v)
+ return rewriteValueS390X_OpS390XMOVBreg_0(v)
case OpS390XMOVBstore:
- return rewriteValueS390X_OpS390XMOVBstore(v)
+ return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v)
case OpS390XMOVBstoreconst:
- return rewriteValueS390X_OpS390XMOVBstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVBstoreconst_0(v)
case OpS390XMOVBstoreidx:
- return rewriteValueS390X_OpS390XMOVBstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v)
case OpS390XMOVDEQ:
- return rewriteValueS390X_OpS390XMOVDEQ(v)
+ return rewriteValueS390X_OpS390XMOVDEQ_0(v)
case OpS390XMOVDGE:
- return rewriteValueS390X_OpS390XMOVDGE(v)
+ return rewriteValueS390X_OpS390XMOVDGE_0(v)
case OpS390XMOVDGT:
- return rewriteValueS390X_OpS390XMOVDGT(v)
+ return rewriteValueS390X_OpS390XMOVDGT_0(v)
case OpS390XMOVDLE:
- return rewriteValueS390X_OpS390XMOVDLE(v)
+ return rewriteValueS390X_OpS390XMOVDLE_0(v)
case OpS390XMOVDLT:
- return rewriteValueS390X_OpS390XMOVDLT(v)
+ return rewriteValueS390X_OpS390XMOVDLT_0(v)
case OpS390XMOVDNE:
- return rewriteValueS390X_OpS390XMOVDNE(v)
+ return rewriteValueS390X_OpS390XMOVDNE_0(v)
case OpS390XMOVDaddridx:
- return rewriteValueS390X_OpS390XMOVDaddridx(v)
+ return rewriteValueS390X_OpS390XMOVDaddridx_0(v)
case OpS390XMOVDload:
- return rewriteValueS390X_OpS390XMOVDload(v)
+ return rewriteValueS390X_OpS390XMOVDload_0(v)
case OpS390XMOVDloadidx:
- return rewriteValueS390X_OpS390XMOVDloadidx(v)
+ return rewriteValueS390X_OpS390XMOVDloadidx_0(v)
case OpS390XMOVDnop:
- return rewriteValueS390X_OpS390XMOVDnop(v)
+ return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v)
case OpS390XMOVDreg:
- return rewriteValueS390X_OpS390XMOVDreg(v)
+ return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v)
case OpS390XMOVDstore:
- return rewriteValueS390X_OpS390XMOVDstore(v)
+ return rewriteValueS390X_OpS390XMOVDstore_0(v)
case OpS390XMOVDstoreconst:
- return rewriteValueS390X_OpS390XMOVDstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVDstoreconst_0(v)
case OpS390XMOVDstoreidx:
- return rewriteValueS390X_OpS390XMOVDstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVDstoreidx_0(v)
case OpS390XMOVHBRstore:
- return rewriteValueS390X_OpS390XMOVHBRstore(v)
+ return rewriteValueS390X_OpS390XMOVHBRstore_0(v)
case OpS390XMOVHBRstoreidx:
- return rewriteValueS390X_OpS390XMOVHBRstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v)
case OpS390XMOVHZload:
- return rewriteValueS390X_OpS390XMOVHZload(v)
+ return rewriteValueS390X_OpS390XMOVHZload_0(v)
case OpS390XMOVHZloadidx:
- return rewriteValueS390X_OpS390XMOVHZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVHZloadidx_0(v)
case OpS390XMOVHZreg:
- return rewriteValueS390X_OpS390XMOVHZreg(v)
+ return rewriteValueS390X_OpS390XMOVHZreg_0(v)
case OpS390XMOVHload:
- return rewriteValueS390X_OpS390XMOVHload(v)
+ return rewriteValueS390X_OpS390XMOVHload_0(v)
case OpS390XMOVHreg:
- return rewriteValueS390X_OpS390XMOVHreg(v)
+ return rewriteValueS390X_OpS390XMOVHreg_0(v)
case OpS390XMOVHstore:
- return rewriteValueS390X_OpS390XMOVHstore(v)
+ return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v)
case OpS390XMOVHstoreconst:
- return rewriteValueS390X_OpS390XMOVHstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVHstoreconst_0(v)
case OpS390XMOVHstoreidx:
- return rewriteValueS390X_OpS390XMOVHstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v)
case OpS390XMOVWBRstore:
- return rewriteValueS390X_OpS390XMOVWBRstore(v)
+ return rewriteValueS390X_OpS390XMOVWBRstore_0(v)
case OpS390XMOVWBRstoreidx:
- return rewriteValueS390X_OpS390XMOVWBRstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v)
case OpS390XMOVWZload:
- return rewriteValueS390X_OpS390XMOVWZload(v)
+ return rewriteValueS390X_OpS390XMOVWZload_0(v)
case OpS390XMOVWZloadidx:
- return rewriteValueS390X_OpS390XMOVWZloadidx(v)
+ return rewriteValueS390X_OpS390XMOVWZloadidx_0(v)
case OpS390XMOVWZreg:
- return rewriteValueS390X_OpS390XMOVWZreg(v)
+ return rewriteValueS390X_OpS390XMOVWZreg_0(v)
case OpS390XMOVWload:
- return rewriteValueS390X_OpS390XMOVWload(v)
+ return rewriteValueS390X_OpS390XMOVWload_0(v)
case OpS390XMOVWreg:
- return rewriteValueS390X_OpS390XMOVWreg(v)
+ return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v)
case OpS390XMOVWstore:
- return rewriteValueS390X_OpS390XMOVWstore(v)
+ return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v)
case OpS390XMOVWstoreconst:
- return rewriteValueS390X_OpS390XMOVWstoreconst(v)
+ return rewriteValueS390X_OpS390XMOVWstoreconst_0(v)
case OpS390XMOVWstoreidx:
- return rewriteValueS390X_OpS390XMOVWstoreidx(v)
+ return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v)
case OpS390XMULLD:
- return rewriteValueS390X_OpS390XMULLD(v)
+ return rewriteValueS390X_OpS390XMULLD_0(v)
case OpS390XMULLDconst:
- return rewriteValueS390X_OpS390XMULLDconst(v)
+ return rewriteValueS390X_OpS390XMULLDconst_0(v)
case OpS390XMULLW:
- return rewriteValueS390X_OpS390XMULLW(v)
+ return rewriteValueS390X_OpS390XMULLW_0(v)
case OpS390XMULLWconst:
- return rewriteValueS390X_OpS390XMULLWconst(v)
+ return rewriteValueS390X_OpS390XMULLWconst_0(v)
case OpS390XNEG:
- return rewriteValueS390X_OpS390XNEG(v)
+ return rewriteValueS390X_OpS390XNEG_0(v)
case OpS390XNEGW:
- return rewriteValueS390X_OpS390XNEGW(v)
+ return rewriteValueS390X_OpS390XNEGW_0(v)
case OpS390XNOT:
- return rewriteValueS390X_OpS390XNOT(v)
+ return rewriteValueS390X_OpS390XNOT_0(v)
case OpS390XNOTW:
- return rewriteValueS390X_OpS390XNOTW(v)
+ return rewriteValueS390X_OpS390XNOTW_0(v)
case OpS390XOR:
- return rewriteValueS390X_OpS390XOR(v)
+ return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v)
case OpS390XORW:
- return rewriteValueS390X_OpS390XORW(v)
+ return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v)
case OpS390XORWconst:
- return rewriteValueS390X_OpS390XORWconst(v)
+ return rewriteValueS390X_OpS390XORWconst_0(v)
case OpS390XORconst:
- return rewriteValueS390X_OpS390XORconst(v)
+ return rewriteValueS390X_OpS390XORconst_0(v)
case OpS390XSLD:
- return rewriteValueS390X_OpS390XSLD(v)
+ return rewriteValueS390X_OpS390XSLD_0(v)
case OpS390XSLW:
- return rewriteValueS390X_OpS390XSLW(v)
+ return rewriteValueS390X_OpS390XSLW_0(v)
case OpS390XSRAD:
- return rewriteValueS390X_OpS390XSRAD(v)
+ return rewriteValueS390X_OpS390XSRAD_0(v)
case OpS390XSRADconst:
- return rewriteValueS390X_OpS390XSRADconst(v)
+ return rewriteValueS390X_OpS390XSRADconst_0(v)
case OpS390XSRAW:
- return rewriteValueS390X_OpS390XSRAW(v)
+ return rewriteValueS390X_OpS390XSRAW_0(v)
case OpS390XSRAWconst:
- return rewriteValueS390X_OpS390XSRAWconst(v)
+ return rewriteValueS390X_OpS390XSRAWconst_0(v)
case OpS390XSRD:
- return rewriteValueS390X_OpS390XSRD(v)
+ return rewriteValueS390X_OpS390XSRD_0(v)
case OpS390XSRW:
- return rewriteValueS390X_OpS390XSRW(v)
+ return rewriteValueS390X_OpS390XSRW_0(v)
case OpS390XSTM2:
- return rewriteValueS390X_OpS390XSTM2(v)
+ return rewriteValueS390X_OpS390XSTM2_0(v)
case OpS390XSTMG2:
- return rewriteValueS390X_OpS390XSTMG2(v)
+ return rewriteValueS390X_OpS390XSTMG2_0(v)
case OpS390XSUB:
- return rewriteValueS390X_OpS390XSUB(v)
+ return rewriteValueS390X_OpS390XSUB_0(v)
case OpS390XSUBEWcarrymask:
- return rewriteValueS390X_OpS390XSUBEWcarrymask(v)
+ return rewriteValueS390X_OpS390XSUBEWcarrymask_0(v)
case OpS390XSUBEcarrymask:
- return rewriteValueS390X_OpS390XSUBEcarrymask(v)
+ return rewriteValueS390X_OpS390XSUBEcarrymask_0(v)
case OpS390XSUBW:
- return rewriteValueS390X_OpS390XSUBW(v)
+ return rewriteValueS390X_OpS390XSUBW_0(v)
case OpS390XSUBWconst:
- return rewriteValueS390X_OpS390XSUBWconst(v)
+ return rewriteValueS390X_OpS390XSUBWconst_0(v)
case OpS390XSUBconst:
- return rewriteValueS390X_OpS390XSUBconst(v)
+ return rewriteValueS390X_OpS390XSUBconst_0(v)
case OpS390XXOR:
- return rewriteValueS390X_OpS390XXOR(v)
+ return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v)
case OpS390XXORW:
- return rewriteValueS390X_OpS390XXORW(v)
+ return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v)
case OpS390XXORWconst:
- return rewriteValueS390X_OpS390XXORWconst(v)
+ return rewriteValueS390X_OpS390XXORWconst_0(v)
case OpS390XXORconst:
- return rewriteValueS390X_OpS390XXORconst(v)
+ return rewriteValueS390X_OpS390XXORconst_0(v)
case OpSelect0:
- return rewriteValueS390X_OpSelect0(v)
+ return rewriteValueS390X_OpSelect0_0(v)
case OpSelect1:
- return rewriteValueS390X_OpSelect1(v)
+ return rewriteValueS390X_OpSelect1_0(v)
case OpSignExt16to32:
- return rewriteValueS390X_OpSignExt16to32(v)
+ return rewriteValueS390X_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValueS390X_OpSignExt16to64(v)
+ return rewriteValueS390X_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValueS390X_OpSignExt32to64(v)
+ return rewriteValueS390X_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValueS390X_OpSignExt8to16(v)
+ return rewriteValueS390X_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValueS390X_OpSignExt8to32(v)
+ return rewriteValueS390X_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValueS390X_OpSignExt8to64(v)
+ return rewriteValueS390X_OpSignExt8to64_0(v)
case OpSlicemask:
- return rewriteValueS390X_OpSlicemask(v)
+ return rewriteValueS390X_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValueS390X_OpSqrt(v)
+ return rewriteValueS390X_OpSqrt_0(v)
case OpStaticCall:
- return rewriteValueS390X_OpStaticCall(v)
+ return rewriteValueS390X_OpStaticCall_0(v)
case OpStore:
- return rewriteValueS390X_OpStore(v)
+ return rewriteValueS390X_OpStore_0(v)
case OpSub16:
- return rewriteValueS390X_OpSub16(v)
+ return rewriteValueS390X_OpSub16_0(v)
case OpSub32:
- return rewriteValueS390X_OpSub32(v)
+ return rewriteValueS390X_OpSub32_0(v)
case OpSub32F:
- return rewriteValueS390X_OpSub32F(v)
+ return rewriteValueS390X_OpSub32F_0(v)
case OpSub64:
- return rewriteValueS390X_OpSub64(v)
+ return rewriteValueS390X_OpSub64_0(v)
case OpSub64F:
- return rewriteValueS390X_OpSub64F(v)
+ return rewriteValueS390X_OpSub64F_0(v)
case OpSub8:
- return rewriteValueS390X_OpSub8(v)
+ return rewriteValueS390X_OpSub8_0(v)
case OpSubPtr:
- return rewriteValueS390X_OpSubPtr(v)
+ return rewriteValueS390X_OpSubPtr_0(v)
case OpTrunc16to8:
- return rewriteValueS390X_OpTrunc16to8(v)
+ return rewriteValueS390X_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValueS390X_OpTrunc32to16(v)
+ return rewriteValueS390X_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValueS390X_OpTrunc32to8(v)
+ return rewriteValueS390X_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValueS390X_OpTrunc64to16(v)
+ return rewriteValueS390X_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValueS390X_OpTrunc64to32(v)
+ return rewriteValueS390X_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValueS390X_OpTrunc64to8(v)
+ return rewriteValueS390X_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValueS390X_OpXor16(v)
+ return rewriteValueS390X_OpXor16_0(v)
case OpXor32:
- return rewriteValueS390X_OpXor32(v)
+ return rewriteValueS390X_OpXor32_0(v)
case OpXor64:
- return rewriteValueS390X_OpXor64(v)
+ return rewriteValueS390X_OpXor64_0(v)
case OpXor8:
- return rewriteValueS390X_OpXor8(v)
+ return rewriteValueS390X_OpXor8_0(v)
case OpZero:
- return rewriteValueS390X_OpZero(v)
+ return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v)
case OpZeroExt16to32:
- return rewriteValueS390X_OpZeroExt16to32(v)
+ return rewriteValueS390X_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValueS390X_OpZeroExt16to64(v)
+ return rewriteValueS390X_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValueS390X_OpZeroExt32to64(v)
+ return rewriteValueS390X_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValueS390X_OpZeroExt8to16(v)
+ return rewriteValueS390X_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValueS390X_OpZeroExt8to32(v)
+ return rewriteValueS390X_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValueS390X_OpZeroExt8to64(v)
+ return rewriteValueS390X_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValueS390X_OpAdd16(v *Value) bool {
+func rewriteValueS390X_OpAdd16_0(v *Value) bool {
// match: (Add16 x y)
// cond:
// result: (ADDW x y)
return true
}
}
-func rewriteValueS390X_OpAdd32(v *Value) bool {
+func rewriteValueS390X_OpAdd32_0(v *Value) bool {
// match: (Add32 x y)
// cond:
// result: (ADDW x y)
return true
}
}
-func rewriteValueS390X_OpAdd32F(v *Value) bool {
+func rewriteValueS390X_OpAdd32F_0(v *Value) bool {
// match: (Add32F x y)
// cond:
// result: (FADDS x y)
return true
}
}
-func rewriteValueS390X_OpAdd64(v *Value) bool {
+func rewriteValueS390X_OpAdd64_0(v *Value) bool {
// match: (Add64 x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueS390X_OpAdd64F(v *Value) bool {
+func rewriteValueS390X_OpAdd64F_0(v *Value) bool {
// match: (Add64F x y)
// cond:
// result: (FADD x y)
return true
}
}
-func rewriteValueS390X_OpAdd8(v *Value) bool {
+func rewriteValueS390X_OpAdd8_0(v *Value) bool {
// match: (Add8 x y)
// cond:
// result: (ADDW x y)
return true
}
}
-func rewriteValueS390X_OpAddPtr(v *Value) bool {
+func rewriteValueS390X_OpAddPtr_0(v *Value) bool {
// match: (AddPtr x y)
// cond:
// result: (ADD x y)
return true
}
}
-func rewriteValueS390X_OpAddr(v *Value) bool {
+func rewriteValueS390X_OpAddr_0(v *Value) bool {
// match: (Addr {sym} base)
// cond:
// result: (MOVDaddr {sym} base)
return true
}
}
-func rewriteValueS390X_OpAnd16(v *Value) bool {
+func rewriteValueS390X_OpAnd16_0(v *Value) bool {
// match: (And16 x y)
// cond:
// result: (ANDW x y)
return true
}
}
-func rewriteValueS390X_OpAnd32(v *Value) bool {
+func rewriteValueS390X_OpAnd32_0(v *Value) bool {
// match: (And32 x y)
// cond:
// result: (ANDW x y)
return true
}
}
-func rewriteValueS390X_OpAnd64(v *Value) bool {
+func rewriteValueS390X_OpAnd64_0(v *Value) bool {
// match: (And64 x y)
// cond:
// result: (AND x y)
return true
}
}
-func rewriteValueS390X_OpAnd8(v *Value) bool {
+func rewriteValueS390X_OpAnd8_0(v *Value) bool {
// match: (And8 x y)
// cond:
// result: (ANDW x y)
return true
}
}
-func rewriteValueS390X_OpAndB(v *Value) bool {
+func rewriteValueS390X_OpAndB_0(v *Value) bool {
// match: (AndB x y)
// cond:
// result: (ANDW x y)
return true
}
}
-func rewriteValueS390X_OpAtomicAdd32(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpAtomicAdd64(v *Value) bool {
+func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool {
// match: (AtomicCompareAndSwap32 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas32 ptr old new_ mem)
return true
}
}
-func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool {
+func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool {
// match: (AtomicCompareAndSwap64 ptr old new_ mem)
// cond:
// result: (LoweredAtomicCas64 ptr old new_ mem)
return true
}
}
-func rewriteValueS390X_OpAtomicExchange32(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool {
// match: (AtomicExchange32 ptr val mem)
// cond:
// result: (LoweredAtomicExchange32 ptr val mem)
return true
}
}
-func rewriteValueS390X_OpAtomicExchange64(v *Value) bool {
+func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool {
// match: (AtomicExchange64 ptr val mem)
// cond:
// result: (LoweredAtomicExchange64 ptr val mem)
return true
}
}
-func rewriteValueS390X_OpAtomicLoad32(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool {
// match: (AtomicLoad32 ptr mem)
// cond:
// result: (MOVWZatomicload ptr mem)
return true
}
}
-func rewriteValueS390X_OpAtomicLoad64(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool {
// match: (AtomicLoad64 ptr mem)
// cond:
// result: (MOVDatomicload ptr mem)
return true
}
}
-func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool {
+func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool {
// match: (AtomicLoadPtr ptr mem)
// cond:
// result: (MOVDatomicload ptr mem)
return true
}
}
-func rewriteValueS390X_OpAtomicStore32(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool {
// match: (AtomicStore32 ptr val mem)
// cond:
// result: (MOVWatomicstore ptr val mem)
return true
}
}
-func rewriteValueS390X_OpAtomicStore64(v *Value) bool {
+func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool {
// match: (AtomicStore64 ptr val mem)
// cond:
// result: (MOVDatomicstore ptr val mem)
return true
}
}
-func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool {
+func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool {
// match: (AtomicStorePtrNoWB ptr val mem)
// cond:
// result: (MOVDatomicstore ptr val mem)
return true
}
}
-func rewriteValueS390X_OpAvg64u(v *Value) bool {
+func rewriteValueS390X_OpAvg64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Avg64u <t> x y)
return true
}
}
-func rewriteValueS390X_OpBitLen64(v *Value) bool {
+func rewriteValueS390X_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpBswap32(v *Value) bool {
+func rewriteValueS390X_OpBswap32_0(v *Value) bool {
// match: (Bswap32 x)
// cond:
// result: (MOVWBR x)
return true
}
}
-func rewriteValueS390X_OpBswap64(v *Value) bool {
+func rewriteValueS390X_OpBswap64_0(v *Value) bool {
// match: (Bswap64 x)
// cond:
// result: (MOVDBR x)
return true
}
}
-func rewriteValueS390X_OpClosureCall(v *Value) bool {
+func rewriteValueS390X_OpClosureCall_0(v *Value) bool {
// match: (ClosureCall [argwid] entry closure mem)
// cond:
// result: (CALLclosure [argwid] entry closure mem)
return true
}
}
-func rewriteValueS390X_OpCom16(v *Value) bool {
+func rewriteValueS390X_OpCom16_0(v *Value) bool {
// match: (Com16 x)
// cond:
// result: (NOTW x)
return true
}
}
-func rewriteValueS390X_OpCom32(v *Value) bool {
+func rewriteValueS390X_OpCom32_0(v *Value) bool {
// match: (Com32 x)
// cond:
// result: (NOTW x)
return true
}
}
-func rewriteValueS390X_OpCom64(v *Value) bool {
+func rewriteValueS390X_OpCom64_0(v *Value) bool {
// match: (Com64 x)
// cond:
// result: (NOT x)
return true
}
}
-func rewriteValueS390X_OpCom8(v *Value) bool {
+func rewriteValueS390X_OpCom8_0(v *Value) bool {
// match: (Com8 x)
// cond:
// result: (NOTW x)
return true
}
}
-func rewriteValueS390X_OpConst16(v *Value) bool {
+func rewriteValueS390X_OpConst16_0(v *Value) bool {
// match: (Const16 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueS390X_OpConst32(v *Value) bool {
+func rewriteValueS390X_OpConst32_0(v *Value) bool {
// match: (Const32 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueS390X_OpConst32F(v *Value) bool {
+func rewriteValueS390X_OpConst32F_0(v *Value) bool {
// match: (Const32F [val])
// cond:
// result: (FMOVSconst [val])
return true
}
}
-func rewriteValueS390X_OpConst64(v *Value) bool {
+func rewriteValueS390X_OpConst64_0(v *Value) bool {
// match: (Const64 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueS390X_OpConst64F(v *Value) bool {
+func rewriteValueS390X_OpConst64F_0(v *Value) bool {
// match: (Const64F [val])
// cond:
// result: (FMOVDconst [val])
return true
}
}
-func rewriteValueS390X_OpConst8(v *Value) bool {
+func rewriteValueS390X_OpConst8_0(v *Value) bool {
// match: (Const8 [val])
// cond:
// result: (MOVDconst [val])
return true
}
}
-func rewriteValueS390X_OpConstBool(v *Value) bool {
+func rewriteValueS390X_OpConstBool_0(v *Value) bool {
// match: (ConstBool [b])
// cond:
// result: (MOVDconst [b])
return true
}
}
-func rewriteValueS390X_OpConstNil(v *Value) bool {
+func rewriteValueS390X_OpConstNil_0(v *Value) bool {
// match: (ConstNil)
// cond:
// result: (MOVDconst [0])
return true
}
}
-func rewriteValueS390X_OpConvert(v *Value) bool {
+func rewriteValueS390X_OpConvert_0(v *Value) bool {
// match: (Convert <t> x mem)
// cond:
// result: (MOVDconvert <t> x mem)
return true
}
}
-func rewriteValueS390X_OpCtz32(v *Value) bool {
+func rewriteValueS390X_OpCtz32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpCtz64(v *Value) bool {
+func rewriteValueS390X_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpCvt32Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool {
// match: (Cvt32Fto32 x)
// cond:
// result: (CFEBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool {
// match: (Cvt32Fto64 x)
// cond:
// result: (CGEBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F x)
// cond:
// result: (LDEBR x)
return true
}
}
-func rewriteValueS390X_OpCvt32to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool {
// match: (Cvt32to32F x)
// cond:
// result: (CEFBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt32to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool {
// match: (Cvt32to64F x)
// cond:
// result: (CDFBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool {
// match: (Cvt64Fto32 x)
// cond:
// result: (CFDBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F x)
// cond:
// result: (LEDBR x)
return true
}
}
-func rewriteValueS390X_OpCvt64Fto64(v *Value) bool {
+func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool {
// match: (Cvt64Fto64 x)
// cond:
// result: (CGDBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt64to32F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool {
// match: (Cvt64to32F x)
// cond:
// result: (CEGBRA x)
return true
}
}
-func rewriteValueS390X_OpCvt64to64F(v *Value) bool {
+func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool {
// match: (Cvt64to64F x)
// cond:
// result: (CDGBRA x)
return true
}
}
-func rewriteValueS390X_OpDiv16(v *Value) bool {
+func rewriteValueS390X_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpDiv16u(v *Value) bool {
+func rewriteValueS390X_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpDiv32(v *Value) bool {
+func rewriteValueS390X_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpDiv32F(v *Value) bool {
+func rewriteValueS390X_OpDiv32F_0(v *Value) bool {
// match: (Div32F x y)
// cond:
// result: (FDIVS x y)
return true
}
}
-func rewriteValueS390X_OpDiv32u(v *Value) bool {
+func rewriteValueS390X_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpDiv64(v *Value) bool {
+func rewriteValueS390X_OpDiv64_0(v *Value) bool {
// match: (Div64 x y)
// cond:
// result: (DIVD x y)
return true
}
}
-func rewriteValueS390X_OpDiv64F(v *Value) bool {
+func rewriteValueS390X_OpDiv64F_0(v *Value) bool {
// match: (Div64F x y)
// cond:
// result: (FDIV x y)
return true
}
}
-func rewriteValueS390X_OpDiv64u(v *Value) bool {
+func rewriteValueS390X_OpDiv64u_0(v *Value) bool {
// match: (Div64u x y)
// cond:
// result: (DIVDU x y)
return true
}
}
-func rewriteValueS390X_OpDiv8(v *Value) bool {
+func rewriteValueS390X_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpDiv8u(v *Value) bool {
+func rewriteValueS390X_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq16(v *Value) bool {
+func rewriteValueS390X_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq32(v *Value) bool {
+func rewriteValueS390X_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq32F(v *Value) bool {
+func rewriteValueS390X_OpEq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq64(v *Value) bool {
+func rewriteValueS390X_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq64F(v *Value) bool {
+func rewriteValueS390X_OpEq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEq8(v *Value) bool {
+func rewriteValueS390X_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEqB(v *Value) bool {
+func rewriteValueS390X_OpEqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpEqPtr(v *Value) bool {
+func rewriteValueS390X_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq16(v *Value) bool {
+func rewriteValueS390X_OpGeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq16U(v *Value) bool {
+func rewriteValueS390X_OpGeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq32(v *Value) bool {
+func rewriteValueS390X_OpGeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq32F(v *Value) bool {
+func rewriteValueS390X_OpGeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq32U(v *Value) bool {
+func rewriteValueS390X_OpGeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq64(v *Value) bool {
+func rewriteValueS390X_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq64F(v *Value) bool {
+func rewriteValueS390X_OpGeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq64U(v *Value) bool {
+func rewriteValueS390X_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq8(v *Value) bool {
+func rewriteValueS390X_OpGeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGeq8U(v *Value) bool {
+func rewriteValueS390X_OpGeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGetClosurePtr(v *Value) bool {
+func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool {
// match: (GetClosurePtr)
// cond:
// result: (LoweredGetClosurePtr)
return true
}
}
-func rewriteValueS390X_OpGetG(v *Value) bool {
+func rewriteValueS390X_OpGetG_0(v *Value) bool {
// match: (GetG mem)
// cond:
// result: (LoweredGetG mem)
return true
}
}
-func rewriteValueS390X_OpGreater16(v *Value) bool {
+func rewriteValueS390X_OpGreater16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater16U(v *Value) bool {
+func rewriteValueS390X_OpGreater16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater32(v *Value) bool {
+func rewriteValueS390X_OpGreater32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater32F(v *Value) bool {
+func rewriteValueS390X_OpGreater32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater32U(v *Value) bool {
+func rewriteValueS390X_OpGreater32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater64(v *Value) bool {
+func rewriteValueS390X_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater64F(v *Value) bool {
+func rewriteValueS390X_OpGreater64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater64U(v *Value) bool {
+func rewriteValueS390X_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater8(v *Value) bool {
+func rewriteValueS390X_OpGreater8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpGreater8U(v *Value) bool {
+func rewriteValueS390X_OpGreater8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpHmul32(v *Value) bool {
+func rewriteValueS390X_OpHmul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpHmul32u(v *Value) bool {
+func rewriteValueS390X_OpHmul32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpHmul64(v *Value) bool {
+func rewriteValueS390X_OpHmul64_0(v *Value) bool {
// match: (Hmul64 x y)
// cond:
// result: (MULHD x y)
return true
}
}
-func rewriteValueS390X_OpHmul64u(v *Value) bool {
+func rewriteValueS390X_OpHmul64u_0(v *Value) bool {
// match: (Hmul64u x y)
// cond:
// result: (MULHDU x y)
return true
}
}
-func rewriteValueS390X_OpITab(v *Value) bool {
+func rewriteValueS390X_OpITab_0(v *Value) bool {
// match: (ITab (Load ptr mem))
// cond:
// result: (MOVDload ptr mem)
}
return false
}
-func rewriteValueS390X_OpInterCall(v *Value) bool {
+func rewriteValueS390X_OpInterCall_0(v *Value) bool {
// match: (InterCall [argwid] entry mem)
// cond:
// result: (CALLinter [argwid] entry mem)
return true
}
}
-func rewriteValueS390X_OpIsInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpIsNonNil(v *Value) bool {
+func rewriteValueS390X_OpIsNonNil_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool {
+func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq16(v *Value) bool {
+func rewriteValueS390X_OpLeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq16U(v *Value) bool {
+func rewriteValueS390X_OpLeq16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq32(v *Value) bool {
+func rewriteValueS390X_OpLeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq32F(v *Value) bool {
+func rewriteValueS390X_OpLeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq32U(v *Value) bool {
+func rewriteValueS390X_OpLeq32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq64(v *Value) bool {
+func rewriteValueS390X_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq64F(v *Value) bool {
+func rewriteValueS390X_OpLeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq64U(v *Value) bool {
+func rewriteValueS390X_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq8(v *Value) bool {
+func rewriteValueS390X_OpLeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLeq8U(v *Value) bool {
+func rewriteValueS390X_OpLeq8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess16(v *Value) bool {
+func rewriteValueS390X_OpLess16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess16U(v *Value) bool {
+func rewriteValueS390X_OpLess16U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess32(v *Value) bool {
+func rewriteValueS390X_OpLess32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess32F(v *Value) bool {
+func rewriteValueS390X_OpLess32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess32U(v *Value) bool {
+func rewriteValueS390X_OpLess32U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess64(v *Value) bool {
+func rewriteValueS390X_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess64F(v *Value) bool {
+func rewriteValueS390X_OpLess64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess64U(v *Value) bool {
+func rewriteValueS390X_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess8(v *Value) bool {
+func rewriteValueS390X_OpLess8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLess8U(v *Value) bool {
+func rewriteValueS390X_OpLess8U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLoad(v *Value) bool {
+func rewriteValueS390X_OpLoad_0(v *Value) bool {
// match: (Load <t> ptr mem)
// cond: (is64BitInt(t) || isPtr(t))
// result: (MOVDload ptr mem)
}
return false
}
-func rewriteValueS390X_OpLsh16x16(v *Value) bool {
+func rewriteValueS390X_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh16x32(v *Value) bool {
+func rewriteValueS390X_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh16x64(v *Value) bool {
+func rewriteValueS390X_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh16x8(v *Value) bool {
+func rewriteValueS390X_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh32x16(v *Value) bool {
+func rewriteValueS390X_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh32x32(v *Value) bool {
+func rewriteValueS390X_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh32x64(v *Value) bool {
+func rewriteValueS390X_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh32x8(v *Value) bool {
+func rewriteValueS390X_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh64x16(v *Value) bool {
+func rewriteValueS390X_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh64x32(v *Value) bool {
+func rewriteValueS390X_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh64x64(v *Value) bool {
+func rewriteValueS390X_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh64x8(v *Value) bool {
+func rewriteValueS390X_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh8x16(v *Value) bool {
+func rewriteValueS390X_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpLsh8x32(v *Value) bool {
+func rewriteValueS390X_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh8x64(v *Value) bool {
+func rewriteValueS390X_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpLsh8x8(v *Value) bool {
+func rewriteValueS390X_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod16(v *Value) bool {
+func rewriteValueS390X_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod16u(v *Value) bool {
+func rewriteValueS390X_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod32(v *Value) bool {
+func rewriteValueS390X_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod32u(v *Value) bool {
+func rewriteValueS390X_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod64(v *Value) bool {
+func rewriteValueS390X_OpMod64_0(v *Value) bool {
// match: (Mod64 x y)
// cond:
// result: (MODD x y)
return true
}
}
-func rewriteValueS390X_OpMod64u(v *Value) bool {
+func rewriteValueS390X_OpMod64u_0(v *Value) bool {
// match: (Mod64u x y)
// cond:
// result: (MODDU x y)
return true
}
}
-func rewriteValueS390X_OpMod8(v *Value) bool {
+func rewriteValueS390X_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMod8u(v *Value) bool {
+func rewriteValueS390X_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpMove(v *Value) bool {
+func rewriteValueS390X_OpMove_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpMove_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (Move [7] dst src mem)
// cond:
// result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem)))
}
return false
}
-func rewriteValueS390X_OpMul16(v *Value) bool {
+func rewriteValueS390X_OpMul16_0(v *Value) bool {
// match: (Mul16 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValueS390X_OpMul32(v *Value) bool {
+func rewriteValueS390X_OpMul32_0(v *Value) bool {
// match: (Mul32 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValueS390X_OpMul32F(v *Value) bool {
+func rewriteValueS390X_OpMul32F_0(v *Value) bool {
// match: (Mul32F x y)
// cond:
// result: (FMULS x y)
return true
}
}
-func rewriteValueS390X_OpMul64(v *Value) bool {
+func rewriteValueS390X_OpMul64_0(v *Value) bool {
// match: (Mul64 x y)
// cond:
// result: (MULLD x y)
return true
}
}
-func rewriteValueS390X_OpMul64F(v *Value) bool {
+func rewriteValueS390X_OpMul64F_0(v *Value) bool {
// match: (Mul64F x y)
// cond:
// result: (FMUL x y)
return true
}
}
-func rewriteValueS390X_OpMul8(v *Value) bool {
+func rewriteValueS390X_OpMul8_0(v *Value) bool {
// match: (Mul8 x y)
// cond:
// result: (MULLW x y)
return true
}
}
-func rewriteValueS390X_OpNeg16(v *Value) bool {
+func rewriteValueS390X_OpNeg16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeg32(v *Value) bool {
+func rewriteValueS390X_OpNeg32_0(v *Value) bool {
// match: (Neg32 x)
// cond:
// result: (NEGW x)
return true
}
}
-func rewriteValueS390X_OpNeg32F(v *Value) bool {
+func rewriteValueS390X_OpNeg32F_0(v *Value) bool {
// match: (Neg32F x)
// cond:
// result: (FNEGS x)
return true
}
}
-func rewriteValueS390X_OpNeg64(v *Value) bool {
+func rewriteValueS390X_OpNeg64_0(v *Value) bool {
// match: (Neg64 x)
// cond:
// result: (NEG x)
return true
}
}
-func rewriteValueS390X_OpNeg64F(v *Value) bool {
+func rewriteValueS390X_OpNeg64F_0(v *Value) bool {
// match: (Neg64F x)
// cond:
// result: (FNEG x)
return true
}
}
-func rewriteValueS390X_OpNeg8(v *Value) bool {
+func rewriteValueS390X_OpNeg8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq16(v *Value) bool {
+func rewriteValueS390X_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq32(v *Value) bool {
+func rewriteValueS390X_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq32F(v *Value) bool {
+func rewriteValueS390X_OpNeq32F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq64(v *Value) bool {
+func rewriteValueS390X_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq64F(v *Value) bool {
+func rewriteValueS390X_OpNeq64F_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeq8(v *Value) bool {
+func rewriteValueS390X_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeqB(v *Value) bool {
+func rewriteValueS390X_OpNeqB_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNeqPtr(v *Value) bool {
+func rewriteValueS390X_OpNeqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpNilCheck(v *Value) bool {
+func rewriteValueS390X_OpNilCheck_0(v *Value) bool {
// match: (NilCheck ptr mem)
// cond:
// result: (LoweredNilCheck ptr mem)
return true
}
}
-func rewriteValueS390X_OpNot(v *Value) bool {
+func rewriteValueS390X_OpNot_0(v *Value) bool {
// match: (Not x)
// cond:
// result: (XORWconst [1] x)
return true
}
}
-func rewriteValueS390X_OpOffPtr(v *Value) bool {
+func rewriteValueS390X_OpOffPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpOr16(v *Value) bool {
+func rewriteValueS390X_OpOr16_0(v *Value) bool {
// match: (Or16 x y)
// cond:
// result: (ORW x y)
return true
}
}
-func rewriteValueS390X_OpOr32(v *Value) bool {
+func rewriteValueS390X_OpOr32_0(v *Value) bool {
// match: (Or32 x y)
// cond:
// result: (ORW x y)
return true
}
}
-func rewriteValueS390X_OpOr64(v *Value) bool {
+func rewriteValueS390X_OpOr64_0(v *Value) bool {
// match: (Or64 x y)
// cond:
// result: (OR x y)
return true
}
}
-func rewriteValueS390X_OpOr8(v *Value) bool {
+func rewriteValueS390X_OpOr8_0(v *Value) bool {
// match: (Or8 x y)
// cond:
// result: (ORW x y)
return true
}
}
-func rewriteValueS390X_OpOrB(v *Value) bool {
+func rewriteValueS390X_OpOrB_0(v *Value) bool {
// match: (OrB x y)
// cond:
// result: (ORW x y)
return true
}
}
-func rewriteValueS390X_OpRound32F(v *Value) bool {
+func rewriteValueS390X_OpRound32F_0(v *Value) bool {
// match: (Round32F x)
// cond:
// result: (LoweredRound32F x)
return true
}
}
-func rewriteValueS390X_OpRound64F(v *Value) bool {
+func rewriteValueS390X_OpRound64F_0(v *Value) bool {
// match: (Round64F x)
// cond:
// result: (LoweredRound64F x)
return true
}
}
-func rewriteValueS390X_OpRsh16Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16x16(v *Value) bool {
+func rewriteValueS390X_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16x32(v *Value) bool {
+func rewriteValueS390X_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16x64(v *Value) bool {
+func rewriteValueS390X_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh16x8(v *Value) bool {
+func rewriteValueS390X_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh32Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh32Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh32Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh32Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh32x16(v *Value) bool {
+func rewriteValueS390X_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh32x32(v *Value) bool {
+func rewriteValueS390X_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh32x64(v *Value) bool {
+func rewriteValueS390X_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh32x8(v *Value) bool {
+func rewriteValueS390X_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh64Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh64Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh64Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh64Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh64x16(v *Value) bool {
+func rewriteValueS390X_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh64x32(v *Value) bool {
+func rewriteValueS390X_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh64x64(v *Value) bool {
+func rewriteValueS390X_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x64 <t> x y)
return true
}
}
-func rewriteValueS390X_OpRsh64x8(v *Value) bool {
+func rewriteValueS390X_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8Ux16(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8Ux32(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8Ux64(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8Ux8(v *Value) bool {
+func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8x16(v *Value) bool {
+func rewriteValueS390X_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8x32(v *Value) bool {
+func rewriteValueS390X_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8x64(v *Value) bool {
+func rewriteValueS390X_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpRsh8x8(v *Value) bool {
+func rewriteValueS390X_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValueS390X_OpS390XADD(v *Value) bool {
+func rewriteValueS390X_OpS390XADD_0(v *Value) bool {
// match: (ADD x (MOVDconst [c]))
// cond: is32Bit(c)
// result: (ADDconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XADD_10(v *Value) bool {
// match: (ADD <t> g:(MOVDload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ADDload <t> [off] {sym} x ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XADDW(v *Value) bool {
+func rewriteValueS390X_OpS390XADDW_0(v *Value) bool {
// match: (ADDW x (MOVDconst [c]))
// cond:
// result: (ADDWconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XADDW_10(v *Value) bool {
// match: (ADDW <t> x g:(MOVWZload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ADDWload <t> [off] {sym} x ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XADDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool {
// match: (ADDWconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XADDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool {
// match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB)))
// cond: ((c+d)&1 == 0) && is32Bit(c+d)
// result: (MOVDaddr [c+d] {s} x)
}
return false
}
-func rewriteValueS390X_OpS390XAND(v *Value) bool {
+func rewriteValueS390X_OpS390XAND_0(v *Value) bool {
// match: (AND x (MOVDconst [c]))
// cond: is32Bit(c) && c < 0
// result: (ANDconst [c] x)
v.AuxInt = c & d
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XAND_10(v *Value) bool {
// match: (AND x x)
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XANDW(v *Value) bool {
+func rewriteValueS390X_OpS390XANDW_0(v *Value) bool {
// match: (ANDW x (MOVDconst [c]))
// cond:
// result: (ANDWconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XANDW_10(v *Value) bool {
// match: (ANDW <t> x g:(MOVWZload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ANDWload <t> [off] {sym} x ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XANDWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool {
// match: (ANDWconst [c] (ANDWconst [d] x))
// cond:
// result: (ANDWconst [c & d] x)
}
return false
}
-func rewriteValueS390X_OpS390XANDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool {
// match: (ANDconst [c] (ANDconst [d] x))
// cond:
// result: (ANDconst [c & d] x)
}
return false
}
-func rewriteValueS390X_OpS390XCMP(v *Value) bool {
+func rewriteValueS390X_OpS390XCMP_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMP x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XCMPU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPU x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool {
// match: (CMPUconst (MOVDconst [x]) [y])
// cond: uint64(x)==uint64(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueS390X_OpS390XCMPW(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPW x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XCMPWU(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool {
b := v.Block
_ = b
// match: (CMPWU x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool {
// match: (CMPWUconst (MOVDconst [x]) [y])
// cond: uint32(x)==uint32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool {
// match: (CMPWconst (MOVDconst [x]) [y])
// cond: int32(x)==int32(y)
// result: (FlagEQ)
}
return false
}
-func rewriteValueS390X_OpS390XCMPconst(v *Value) bool {
+func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool {
// match: (CMPconst (MOVDconst [x]) [y])
// cond: x==y
// result: (FlagEQ)
}
return false
}
-func rewriteValueS390X_OpS390XFADD(v *Value) bool {
+func rewriteValueS390X_OpS390XFADD_0(v *Value) bool {
// match: (FADD (FMUL y z) x)
// cond:
// result: (FMADD x y z)
}
return false
}
-func rewriteValueS390X_OpS390XFADDS(v *Value) bool {
+func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool {
// match: (FADDS (FMULS y z) x)
// cond:
// result: (FMADDS x y z)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool {
// match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (FMOVDload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool {
// match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (FMOVDloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool {
// match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (FMOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool {
// match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool {
// match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (FMOVSload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool {
// match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (FMOVSloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool {
// match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (FMOVSstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool {
// match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueS390X_OpS390XFSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool {
// match: (FSUB (FMUL y z) x)
// cond:
// result: (FMSUB x y z)
}
return false
}
-func rewriteValueS390X_OpS390XFSUBS(v *Value) bool {
+func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool {
// match: (FSUBS (FMULS y z) x)
// cond:
// result: (FMSUBS x y z)
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool {
// match: (LoweredRound32F x:(FMOVSconst))
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool {
+func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool {
// match: (LoweredRound64F x:(FMOVDconst))
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool {
// match: (MOVBZload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVBZreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool {
// match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVBZloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool {
// match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _))
// cond: int64(uint8(c)) == c && int64(uint8(d)) == d
// result: (MOVDreg x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVBZreg x:(MOVBZreg _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool {
// match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVBload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVBreg x:(MOVBload _ _))
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool {
// match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem)
// cond:
// result: (MOVBstore [off] {sym} ptr x mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool {
// match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem))
// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
// result: (MOVHstore [i-1] {s} p w0 mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool {
// match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool {
// match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVBstoreidx [c+d] {sym} ptr idx val mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool {
// match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHstoreidx [i-1] {s} p idx w0 mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool {
// match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool {
// match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVHBRstoreidx [i-1] {s} p idx w mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool {
// match: (MOVDEQ x y (InvertFlags cmp))
// cond:
// result: (MOVDEQ x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool {
// match: (MOVDGE x y (InvertFlags cmp))
// cond:
// result: (MOVDLE x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool {
// match: (MOVDGT x y (InvertFlags cmp))
// cond:
// result: (MOVDLT x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool {
// match: (MOVDLE x y (InvertFlags cmp))
// cond:
// result: (MOVDGE x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool {
// match: (MOVDLT x y (InvertFlags cmp))
// cond:
// result: (MOVDGT x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool {
// match: (MOVDNE x y (InvertFlags cmp))
// cond:
// result: (MOVDNE x y cmp)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool {
// match: (MOVDaddridx [c] {s} (ADDconst [d] x) y)
// cond: is20Bit(c+d) && x.Op != OpSB
// result: (MOVDaddridx [c+d] {s} x y)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool {
// match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVDreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool {
// match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVDloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVDnop <t> x)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVDnop <t> x:(MOVHZloadidx [off] {sym} ptr idx mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVHZloadidx <t> [off] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVDreg <t> x)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVDreg <t> x:(MOVBZloadidx [off] {sym} ptr idx mem))
// cond: x.Uses == 1 && clobber(x)
// result: @x.Block (MOVBZloadidx <t> [off] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool {
// match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem)
// cond: is20Bit(off1+off2)
// result: (MOVDstore [off1+off2] {sym} ptr val mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool {
// match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool {
// match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVDstoreidx [c+d] {sym} ptr idx val mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool {
// match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstore [i-2] {s} p w mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool {
// match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool {
// match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWBRstoreidx [i-2] {s} p idx w mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool {
// match: (MOVHZload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVHZreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool {
// match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVHZloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHZreg x:(MOVBZload _ _))
}
return false
}
-func rewriteValueS390X_OpS390XMOVHload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool {
// match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVHload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVHreg x:(MOVBload _ _))
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool {
// match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem)
// cond:
// result: (MOVHstore [off] {sym} ptr x mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool {
// match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem))
// cond: p.Op != OpSB && x.Uses == 1 && clobber(x)
// result: (MOVWstore [i-2] {s} p w0 mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool {
// match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem)
// cond: ValAndOff(sc).canAdd(off)
// result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool {
// match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVHstoreidx [c+d] {sym} ptr idx val mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool {
// match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVWstoreidx [i-2] {s} p idx w0 mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool {
// match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDBRstore [i-4] {s} p w mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool {
// match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDBRstoreidx [i-4] {s} p idx w mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool {
// match: (MOVWZload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _))
// cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2)
// result: (MOVWZreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool {
// match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem)
// cond:
// result: (MOVWZloadidx [c+d] {sym} ptr idx mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool {
b := v.Block
_ = b
// match: (MOVWZreg x:(MOVBZload _ _))
}
return false
}
-func rewriteValueS390X_OpS390XMOVWload(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool {
// match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem)
// cond: is20Bit(off1+off2)
// result: (MOVWload [off1+off2] {sym} ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool {
// match: (MOVWreg x:(MOVBload _ _))
// cond:
// result: (MOVDreg x)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (MOVWreg x:(MOVWreg _))
// cond:
// result: (MOVDreg x)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool {
// match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem)
// cond:
// result: (MOVWstore [off] {sym} ptr x mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool {
// match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
// result: (STM3 [i-8] {s} p w0 w1 w2 mem)
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool {
+func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool {
// match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem)
// cond:
// result: (MOVWstoreidx [c+d] {sym} ptr idx val mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool {
// match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem))
// cond: x.Uses == 1 && clobber(x)
// result: (MOVDstoreidx [i-4] {s} p idx w0 mem)
}
return false
}
-func rewriteValueS390X_OpS390XMULLD(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool {
// match: (MULLD x (MOVDconst [c]))
// cond: is32Bit(c)
// result: (MULLDconst [c] x)
}
return false
}
-func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLDconst [-1] x)
}
return false
}
-func rewriteValueS390X_OpS390XMULLW(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool {
// match: (MULLW x (MOVDconst [c]))
// cond:
// result: (MULLWconst [c] x)
}
return false
}
-func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool {
b := v.Block
_ = b
// match: (MULLWconst [-1] x)
}
return false
}
-func rewriteValueS390X_OpS390XNEG(v *Value) bool {
+func rewriteValueS390X_OpS390XNEG_0(v *Value) bool {
// match: (NEG (MOVDconst [c]))
// cond:
// result: (MOVDconst [-c])
}
return false
}
-func rewriteValueS390X_OpS390XNEGW(v *Value) bool {
+func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool {
// match: (NEGW (MOVDconst [c]))
// cond:
// result: (MOVDconst [int64(int32(-c))])
}
return false
}
-func rewriteValueS390X_OpS390XNOT(v *Value) bool {
+func rewriteValueS390X_OpS390XNOT_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValueS390X_OpS390XNOTW(v *Value) bool {
+func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool {
// match: (NOTW x)
// cond: true
// result: (XORWconst [-1] x)
}
return false
}
-func rewriteValueS390X_OpS390XOR(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueS390X_OpS390XOR_0(v *Value) bool {
// match: (OR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (ORconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR <t> x g:(MOVDload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ORload <t> [off] {sym} x ptr mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem))
// cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem))
// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)) or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} p idx mem))))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s1:(SLDconst [j1] x1:(MOVHZloadidx [i1] {s} idx p mem))) s0:(SLDconst [j0] x0:(MOVHZloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+2 && j1 == j0-16 && j1 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j1] (MOVWZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLDconst [j1] x1:(MOVBZload [i1] {s} p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_100(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem))
// cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))
v0.AddArg(v1)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_110(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_120(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(OR s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} p idx mem)) y))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_130(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem))) s1:(SLDconst [j1] x1:(MOVBZloadidx [i1] {s} p idx mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_140(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} p idx mem)))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XOR_150(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (OR or:(OR y s0:(SLDconst [j0] r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)))) s1:(SLDconst [j1] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))))
// cond: i1 == i0+2 && j1 == j0+16 && j0 % 32 == 0 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (OR <v.Type> (SLDconst <v.Type> [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y)
}
return false
}
-func rewriteValueS390X_OpS390XORW(v *Value) bool {
- b := v.Block
- _ = b
- types := &b.Func.Config.Types
- _ = types
+func rewriteValueS390X_OpS390XORW_0(v *Value) bool {
// match: (ORW x (MOVDconst [c]))
// cond:
// result: (ORWconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (ORWload <t> [off] {sym} x ptr mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_20(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW y s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem))) s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZload [i0] {s} p mem)) y)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_30(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem)))
// cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_40(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_50(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) y) s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)))
// cond: i1 == i0+1 && j1 == j0-8 && j1 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j1] (MOVHZloadidx [i0] {s} p idx mem)) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_60(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW y s0:(SLWconst [j0] x0:(MOVBZload [i0] {s} p mem))) s1:(SLWconst [j1] x1:(MOVBZload [i1] {s} p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y)
v0.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_70(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem))))
// cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh)
// result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_80(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)) or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
v0.AddArg(y)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XORW_90(v *Value) bool {
+ b := v.Block
+ _ = b
+ types := &b.Func.Config.Types
+ _ = types
// match: (ORW or:(ORW s0:(SLWconst [j0] x0:(MOVBZloadidx [i0] {s} idx p mem)) y) s1:(SLWconst [j1] x1:(MOVBZloadidx [i1] {s} idx p mem)))
// cond: p.Op != OpSB && i1 == i0+1 && j1 == j0+8 && j0 % 16 == 0 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && s1.Uses == 1 && or.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) && clobber(s1) && clobber(or)
// result: @mergePoint(b,x0,x1) (ORW <v.Type> (SLWconst <v.Type> [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y)
}
return false
}
-func rewriteValueS390X_OpS390XORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool {
// match: (ORWconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XORconst_0(v *Value) bool {
// match: (ORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XSLD(v *Value) bool {
+func rewriteValueS390X_OpS390XSLD_0(v *Value) bool {
// match: (SLD x (MOVDconst [c]))
// cond:
// result: (SLDconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSLW(v *Value) bool {
+func rewriteValueS390X_OpS390XSLW_0(v *Value) bool {
// match: (SLW x (MOVDconst [c]))
// cond:
// result: (SLWconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSRAD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool {
// match: (SRAD x (MOVDconst [c]))
// cond:
// result: (SRADconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSRADconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool {
// match: (SRADconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [d>>uint64(c)])
}
return false
}
-func rewriteValueS390X_OpS390XSRAW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool {
// match: (SRAW x (MOVDconst [c]))
// cond:
// result: (SRAWconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool {
// match: (SRAWconst [c] (MOVDconst [d]))
// cond:
// result: (MOVDconst [d>>uint64(c)])
}
return false
}
-func rewriteValueS390X_OpS390XSRD(v *Value) bool {
+func rewriteValueS390X_OpS390XSRD_0(v *Value) bool {
// match: (SRD x (MOVDconst [c]))
// cond:
// result: (SRDconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSRW(v *Value) bool {
+func rewriteValueS390X_OpS390XSRW_0(v *Value) bool {
// match: (SRW x (MOVDconst [c]))
// cond:
// result: (SRWconst [c&63] x)
}
return false
}
-func rewriteValueS390X_OpS390XSTM2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool {
// match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-8) && clobber(x)
// result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem)
}
return false
}
-func rewriteValueS390X_OpS390XSTMG2(v *Value) bool {
+func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool {
// match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem))
// cond: x.Uses == 1 && is20Bit(i-16) && clobber(x)
// result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem)
}
return false
}
-func rewriteValueS390X_OpS390XSUB(v *Value) bool {
+func rewriteValueS390X_OpS390XSUB_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUB x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEWcarrymask_0(v *Value) bool {
// match: (SUBEWcarrymask (FlagEQ))
// cond:
// result: (MOVDconst [-1])
}
return false
}
-func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBEcarrymask_0(v *Value) bool {
// match: (SUBEcarrymask (FlagEQ))
// cond:
// result: (MOVDconst [-1])
}
return false
}
-func rewriteValueS390X_OpS390XSUBW(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool {
b := v.Block
_ = b
// match: (SUBW x (MOVDconst [c]))
}
return false
}
-func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool {
// match: (SUBWconst [c] x)
// cond: int32(c) == 0
// result: x
return true
}
}
-func rewriteValueS390X_OpS390XSUBconst(v *Value) bool {
+func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool {
// match: (SUBconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XXOR(v *Value) bool {
+func rewriteValueS390X_OpS390XXOR_0(v *Value) bool {
// match: (XOR x (MOVDconst [c]))
// cond: isU32Bit(c)
// result: (XORconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XXOR_10(v *Value) bool {
// match: (XOR <t> x g:(MOVDload [off] {sym} ptr mem))
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (XORload <t> [off] {sym} x ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XXORW(v *Value) bool {
+func rewriteValueS390X_OpS390XXORW_0(v *Value) bool {
// match: (XORW x (MOVDconst [c]))
// cond:
// result: (XORWconst [c] x)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpS390XXORW_10(v *Value) bool {
// match: (XORW <t> g:(MOVWZload [off] {sym} ptr mem) x)
// cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g)
// result: (XORWload <t> [off] {sym} x ptr mem)
}
return false
}
-func rewriteValueS390X_OpS390XXORWconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool {
// match: (XORWconst [c] x)
// cond: int32(c)==0
// result: x
}
return false
}
-func rewriteValueS390X_OpS390XXORconst(v *Value) bool {
+func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool {
// match: (XORconst [0] x)
// cond:
// result: x
}
return false
}
-func rewriteValueS390X_OpSelect0(v *Value) bool {
+func rewriteValueS390X_OpSelect0_0(v *Value) bool {
b := v.Block
_ = b
// match: (Select0 <t> (AddTupleFirst32 tuple val))
}
return false
}
-func rewriteValueS390X_OpSelect1(v *Value) bool {
+func rewriteValueS390X_OpSelect1_0(v *Value) bool {
// match: (Select1 (AddTupleFirst32 tuple _))
// cond:
// result: (Select1 tuple)
}
return false
}
-func rewriteValueS390X_OpSignExt16to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueS390X_OpSignExt16to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 x)
// cond:
// result: (MOVHreg x)
return true
}
}
-func rewriteValueS390X_OpSignExt32to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 x)
// cond:
// result: (MOVWreg x)
return true
}
}
-func rewriteValueS390X_OpSignExt8to16(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueS390X_OpSignExt8to32(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueS390X_OpSignExt8to64(v *Value) bool {
+func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 x)
// cond:
// result: (MOVBreg x)
return true
}
}
-func rewriteValueS390X_OpSlicemask(v *Value) bool {
+func rewriteValueS390X_OpSlicemask_0(v *Value) bool {
b := v.Block
_ = b
// match: (Slicemask <t> x)
return true
}
}
-func rewriteValueS390X_OpSqrt(v *Value) bool {
+func rewriteValueS390X_OpSqrt_0(v *Value) bool {
// match: (Sqrt x)
// cond:
// result: (FSQRT x)
return true
}
}
-func rewriteValueS390X_OpStaticCall(v *Value) bool {
+func rewriteValueS390X_OpStaticCall_0(v *Value) bool {
// match: (StaticCall [argwid] {target} mem)
// cond:
// result: (CALLstatic [argwid] {target} mem)
return true
}
}
-func rewriteValueS390X_OpStore(v *Value) bool {
+func rewriteValueS390X_OpStore_0(v *Value) bool {
// match: (Store {t} ptr val mem)
// cond: t.(Type).Size() == 8 && is64BitFloat(val.Type)
// result: (FMOVDstore ptr val mem)
}
return false
}
-func rewriteValueS390X_OpSub16(v *Value) bool {
+func rewriteValueS390X_OpSub16_0(v *Value) bool {
// match: (Sub16 x y)
// cond:
// result: (SUBW x y)
return true
}
}
-func rewriteValueS390X_OpSub32(v *Value) bool {
+func rewriteValueS390X_OpSub32_0(v *Value) bool {
// match: (Sub32 x y)
// cond:
// result: (SUBW x y)
return true
}
}
-func rewriteValueS390X_OpSub32F(v *Value) bool {
+func rewriteValueS390X_OpSub32F_0(v *Value) bool {
// match: (Sub32F x y)
// cond:
// result: (FSUBS x y)
return true
}
}
-func rewriteValueS390X_OpSub64(v *Value) bool {
+func rewriteValueS390X_OpSub64_0(v *Value) bool {
// match: (Sub64 x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueS390X_OpSub64F(v *Value) bool {
+func rewriteValueS390X_OpSub64F_0(v *Value) bool {
// match: (Sub64F x y)
// cond:
// result: (FSUB x y)
return true
}
}
-func rewriteValueS390X_OpSub8(v *Value) bool {
+func rewriteValueS390X_OpSub8_0(v *Value) bool {
// match: (Sub8 x y)
// cond:
// result: (SUBW x y)
return true
}
}
-func rewriteValueS390X_OpSubPtr(v *Value) bool {
+func rewriteValueS390X_OpSubPtr_0(v *Value) bool {
// match: (SubPtr x y)
// cond:
// result: (SUB x y)
return true
}
}
-func rewriteValueS390X_OpTrunc16to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpTrunc32to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpTrunc32to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpTrunc64to16(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpTrunc64to32(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpTrunc64to8(v *Value) bool {
+func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 x)
// cond:
// result: x
return true
}
}
-func rewriteValueS390X_OpXor16(v *Value) bool {
+func rewriteValueS390X_OpXor16_0(v *Value) bool {
// match: (Xor16 x y)
// cond:
// result: (XORW x y)
return true
}
}
-func rewriteValueS390X_OpXor32(v *Value) bool {
+func rewriteValueS390X_OpXor32_0(v *Value) bool {
// match: (Xor32 x y)
// cond:
// result: (XORW x y)
return true
}
}
-func rewriteValueS390X_OpXor64(v *Value) bool {
+func rewriteValueS390X_OpXor64_0(v *Value) bool {
// match: (Xor64 x y)
// cond:
// result: (XOR x y)
return true
}
}
-func rewriteValueS390X_OpXor8(v *Value) bool {
+func rewriteValueS390X_OpXor8_0(v *Value) bool {
// match: (Xor8 x y)
// cond:
// result: (XORW x y)
return true
}
}
-func rewriteValueS390X_OpZero(v *Value) bool {
+func rewriteValueS390X_OpZero_0(v *Value) bool {
b := v.Block
_ = b
// match: (Zero [0] _ mem)
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValueS390X_OpZero_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Zero [s] destptr mem)
// cond: s > 1024
// result: (LoweredZero [s%256] destptr (ADDconst <destptr.Type> destptr [(s/256)*256]) mem)
}
return false
}
-func rewriteValueS390X_OpZeroExt16to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 x)
// cond:
// result: (MOVHZreg x)
return true
}
}
-func rewriteValueS390X_OpZeroExt16to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 x)
// cond:
// result: (MOVHZreg x)
return true
}
}
-func rewriteValueS390X_OpZeroExt32to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 x)
// cond:
// result: (MOVWZreg x)
return true
}
}
-func rewriteValueS390X_OpZeroExt8to16(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 x)
// cond:
// result: (MOVBZreg x)
return true
}
}
-func rewriteValueS390X_OpZeroExt8to32(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 x)
// cond:
// result: (MOVBZreg x)
return true
}
}
-func rewriteValueS390X_OpZeroExt8to64(v *Value) bool {
+func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 x)
// cond:
// result: (MOVBZreg x)
func rewriteValuedec(v *Value) bool {
switch v.Op {
case OpComplexImag:
- return rewriteValuedec_OpComplexImag(v)
+ return rewriteValuedec_OpComplexImag_0(v)
case OpComplexReal:
- return rewriteValuedec_OpComplexReal(v)
+ return rewriteValuedec_OpComplexReal_0(v)
case OpIData:
- return rewriteValuedec_OpIData(v)
+ return rewriteValuedec_OpIData_0(v)
case OpITab:
- return rewriteValuedec_OpITab(v)
+ return rewriteValuedec_OpITab_0(v)
case OpLoad:
- return rewriteValuedec_OpLoad(v)
+ return rewriteValuedec_OpLoad_0(v)
case OpSliceCap:
- return rewriteValuedec_OpSliceCap(v)
+ return rewriteValuedec_OpSliceCap_0(v)
case OpSliceLen:
- return rewriteValuedec_OpSliceLen(v)
+ return rewriteValuedec_OpSliceLen_0(v)
case OpSlicePtr:
- return rewriteValuedec_OpSlicePtr(v)
+ return rewriteValuedec_OpSlicePtr_0(v)
case OpStore:
- return rewriteValuedec_OpStore(v)
+ return rewriteValuedec_OpStore_0(v)
case OpStringLen:
- return rewriteValuedec_OpStringLen(v)
+ return rewriteValuedec_OpStringLen_0(v)
case OpStringPtr:
- return rewriteValuedec_OpStringPtr(v)
+ return rewriteValuedec_OpStringPtr_0(v)
}
return false
}
-func rewriteValuedec_OpComplexImag(v *Value) bool {
+func rewriteValuedec_OpComplexImag_0(v *Value) bool {
// match: (ComplexImag (ComplexMake _ imag))
// cond:
// result: imag
}
return false
}
-func rewriteValuedec_OpComplexReal(v *Value) bool {
+func rewriteValuedec_OpComplexReal_0(v *Value) bool {
// match: (ComplexReal (ComplexMake real _))
// cond:
// result: real
}
return false
}
-func rewriteValuedec_OpIData(v *Value) bool {
+func rewriteValuedec_OpIData_0(v *Value) bool {
// match: (IData (IMake _ data))
// cond:
// result: data
}
return false
}
-func rewriteValuedec_OpITab(v *Value) bool {
+func rewriteValuedec_OpITab_0(v *Value) bool {
b := v.Block
_ = b
// match: (ITab (IMake itab _))
}
return false
}
-func rewriteValuedec_OpLoad(v *Value) bool {
+func rewriteValuedec_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuedec_OpSliceCap(v *Value) bool {
+func rewriteValuedec_OpSliceCap_0(v *Value) bool {
// match: (SliceCap (SliceMake _ _ cap))
// cond:
// result: cap
}
return false
}
-func rewriteValuedec_OpSliceLen(v *Value) bool {
+func rewriteValuedec_OpSliceLen_0(v *Value) bool {
// match: (SliceLen (SliceMake _ len _))
// cond:
// result: len
}
return false
}
-func rewriteValuedec_OpSlicePtr(v *Value) bool {
+func rewriteValuedec_OpSlicePtr_0(v *Value) bool {
// match: (SlicePtr (SliceMake ptr _ _))
// cond:
// result: ptr
}
return false
}
-func rewriteValuedec_OpStore(v *Value) bool {
+func rewriteValuedec_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuedec_OpStringLen(v *Value) bool {
+func rewriteValuedec_OpStringLen_0(v *Value) bool {
// match: (StringLen (StringMake _ len))
// cond:
// result: len
}
return false
}
-func rewriteValuedec_OpStringPtr(v *Value) bool {
+func rewriteValuedec_OpStringPtr_0(v *Value) bool {
// match: (StringPtr (StringMake ptr _))
// cond:
// result: ptr
func rewriteValuedec64(v *Value) bool {
switch v.Op {
case OpAdd64:
- return rewriteValuedec64_OpAdd64(v)
+ return rewriteValuedec64_OpAdd64_0(v)
case OpAnd64:
- return rewriteValuedec64_OpAnd64(v)
+ return rewriteValuedec64_OpAnd64_0(v)
case OpArg:
- return rewriteValuedec64_OpArg(v)
+ return rewriteValuedec64_OpArg_0(v)
case OpBitLen64:
- return rewriteValuedec64_OpBitLen64(v)
+ return rewriteValuedec64_OpBitLen64_0(v)
case OpBswap64:
- return rewriteValuedec64_OpBswap64(v)
+ return rewriteValuedec64_OpBswap64_0(v)
case OpCom64:
- return rewriteValuedec64_OpCom64(v)
+ return rewriteValuedec64_OpCom64_0(v)
case OpConst64:
- return rewriteValuedec64_OpConst64(v)
+ return rewriteValuedec64_OpConst64_0(v)
case OpCtz64:
- return rewriteValuedec64_OpCtz64(v)
+ return rewriteValuedec64_OpCtz64_0(v)
case OpEq64:
- return rewriteValuedec64_OpEq64(v)
+ return rewriteValuedec64_OpEq64_0(v)
case OpGeq64:
- return rewriteValuedec64_OpGeq64(v)
+ return rewriteValuedec64_OpGeq64_0(v)
case OpGeq64U:
- return rewriteValuedec64_OpGeq64U(v)
+ return rewriteValuedec64_OpGeq64U_0(v)
case OpGreater64:
- return rewriteValuedec64_OpGreater64(v)
+ return rewriteValuedec64_OpGreater64_0(v)
case OpGreater64U:
- return rewriteValuedec64_OpGreater64U(v)
+ return rewriteValuedec64_OpGreater64U_0(v)
case OpInt64Hi:
- return rewriteValuedec64_OpInt64Hi(v)
+ return rewriteValuedec64_OpInt64Hi_0(v)
case OpInt64Lo:
- return rewriteValuedec64_OpInt64Lo(v)
+ return rewriteValuedec64_OpInt64Lo_0(v)
case OpLeq64:
- return rewriteValuedec64_OpLeq64(v)
+ return rewriteValuedec64_OpLeq64_0(v)
case OpLeq64U:
- return rewriteValuedec64_OpLeq64U(v)
+ return rewriteValuedec64_OpLeq64U_0(v)
case OpLess64:
- return rewriteValuedec64_OpLess64(v)
+ return rewriteValuedec64_OpLess64_0(v)
case OpLess64U:
- return rewriteValuedec64_OpLess64U(v)
+ return rewriteValuedec64_OpLess64U_0(v)
case OpLoad:
- return rewriteValuedec64_OpLoad(v)
+ return rewriteValuedec64_OpLoad_0(v)
case OpLsh16x64:
- return rewriteValuedec64_OpLsh16x64(v)
+ return rewriteValuedec64_OpLsh16x64_0(v)
case OpLsh32x64:
- return rewriteValuedec64_OpLsh32x64(v)
+ return rewriteValuedec64_OpLsh32x64_0(v)
case OpLsh64x16:
- return rewriteValuedec64_OpLsh64x16(v)
+ return rewriteValuedec64_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValuedec64_OpLsh64x32(v)
+ return rewriteValuedec64_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValuedec64_OpLsh64x64(v)
+ return rewriteValuedec64_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValuedec64_OpLsh64x8(v)
+ return rewriteValuedec64_OpLsh64x8_0(v)
case OpLsh8x64:
- return rewriteValuedec64_OpLsh8x64(v)
+ return rewriteValuedec64_OpLsh8x64_0(v)
case OpMul64:
- return rewriteValuedec64_OpMul64(v)
+ return rewriteValuedec64_OpMul64_0(v)
case OpNeg64:
- return rewriteValuedec64_OpNeg64(v)
+ return rewriteValuedec64_OpNeg64_0(v)
case OpNeq64:
- return rewriteValuedec64_OpNeq64(v)
+ return rewriteValuedec64_OpNeq64_0(v)
case OpOr64:
- return rewriteValuedec64_OpOr64(v)
+ return rewriteValuedec64_OpOr64_0(v)
case OpRsh16Ux64:
- return rewriteValuedec64_OpRsh16Ux64(v)
+ return rewriteValuedec64_OpRsh16Ux64_0(v)
case OpRsh16x64:
- return rewriteValuedec64_OpRsh16x64(v)
+ return rewriteValuedec64_OpRsh16x64_0(v)
case OpRsh32Ux64:
- return rewriteValuedec64_OpRsh32Ux64(v)
+ return rewriteValuedec64_OpRsh32Ux64_0(v)
case OpRsh32x64:
- return rewriteValuedec64_OpRsh32x64(v)
+ return rewriteValuedec64_OpRsh32x64_0(v)
case OpRsh64Ux16:
- return rewriteValuedec64_OpRsh64Ux16(v)
+ return rewriteValuedec64_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValuedec64_OpRsh64Ux32(v)
+ return rewriteValuedec64_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValuedec64_OpRsh64Ux64(v)
+ return rewriteValuedec64_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValuedec64_OpRsh64Ux8(v)
+ return rewriteValuedec64_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValuedec64_OpRsh64x16(v)
+ return rewriteValuedec64_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValuedec64_OpRsh64x32(v)
+ return rewriteValuedec64_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValuedec64_OpRsh64x64(v)
+ return rewriteValuedec64_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValuedec64_OpRsh64x8(v)
+ return rewriteValuedec64_OpRsh64x8_0(v)
case OpRsh8Ux64:
- return rewriteValuedec64_OpRsh8Ux64(v)
+ return rewriteValuedec64_OpRsh8Ux64_0(v)
case OpRsh8x64:
- return rewriteValuedec64_OpRsh8x64(v)
+ return rewriteValuedec64_OpRsh8x64_0(v)
case OpSignExt16to64:
- return rewriteValuedec64_OpSignExt16to64(v)
+ return rewriteValuedec64_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValuedec64_OpSignExt32to64(v)
+ return rewriteValuedec64_OpSignExt32to64_0(v)
case OpSignExt8to64:
- return rewriteValuedec64_OpSignExt8to64(v)
+ return rewriteValuedec64_OpSignExt8to64_0(v)
case OpStore:
- return rewriteValuedec64_OpStore(v)
+ return rewriteValuedec64_OpStore_0(v)
case OpSub64:
- return rewriteValuedec64_OpSub64(v)
+ return rewriteValuedec64_OpSub64_0(v)
case OpTrunc64to16:
- return rewriteValuedec64_OpTrunc64to16(v)
+ return rewriteValuedec64_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValuedec64_OpTrunc64to32(v)
+ return rewriteValuedec64_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValuedec64_OpTrunc64to8(v)
+ return rewriteValuedec64_OpTrunc64to8_0(v)
case OpXor64:
- return rewriteValuedec64_OpXor64(v)
+ return rewriteValuedec64_OpXor64_0(v)
case OpZeroExt16to64:
- return rewriteValuedec64_OpZeroExt16to64(v)
+ return rewriteValuedec64_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValuedec64_OpZeroExt32to64(v)
+ return rewriteValuedec64_OpZeroExt32to64_0(v)
case OpZeroExt8to64:
- return rewriteValuedec64_OpZeroExt8to64(v)
+ return rewriteValuedec64_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValuedec64_OpAdd64(v *Value) bool {
+func rewriteValuedec64_OpAdd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpAnd64(v *Value) bool {
+func rewriteValuedec64_OpAnd64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpArg(v *Value) bool {
+func rewriteValuedec64_OpArg_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuedec64_OpBitLen64(v *Value) bool {
+func rewriteValuedec64_OpBitLen64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpBswap64(v *Value) bool {
+func rewriteValuedec64_OpBswap64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpCom64(v *Value) bool {
+func rewriteValuedec64_OpCom64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpConst64(v *Value) bool {
+func rewriteValuedec64_OpConst64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpCtz64(v *Value) bool {
+func rewriteValuedec64_OpCtz64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpEq64(v *Value) bool {
+func rewriteValuedec64_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpGeq64(v *Value) bool {
+func rewriteValuedec64_OpGeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpGeq64U(v *Value) bool {
+func rewriteValuedec64_OpGeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpGreater64(v *Value) bool {
+func rewriteValuedec64_OpGreater64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpGreater64U(v *Value) bool {
+func rewriteValuedec64_OpGreater64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpInt64Hi(v *Value) bool {
+func rewriteValuedec64_OpInt64Hi_0(v *Value) bool {
// match: (Int64Hi (Int64Make hi _))
// cond:
// result: hi
}
return false
}
-func rewriteValuedec64_OpInt64Lo(v *Value) bool {
+func rewriteValuedec64_OpInt64Lo_0(v *Value) bool {
// match: (Int64Lo (Int64Make _ lo))
// cond:
// result: lo
}
return false
}
-func rewriteValuedec64_OpLeq64(v *Value) bool {
+func rewriteValuedec64_OpLeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpLeq64U(v *Value) bool {
+func rewriteValuedec64_OpLeq64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpLess64(v *Value) bool {
+func rewriteValuedec64_OpLess64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpLess64U(v *Value) bool {
+func rewriteValuedec64_OpLess64U_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpLoad(v *Value) bool {
+func rewriteValuedec64_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuedec64_OpLsh16x64(v *Value) bool {
+func rewriteValuedec64_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh32x64(v *Value) bool {
+func rewriteValuedec64_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh64x16(v *Value) bool {
+func rewriteValuedec64_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh64x32(v *Value) bool {
+func rewriteValuedec64_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh64x64(v *Value) bool {
+func rewriteValuedec64_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh64x8(v *Value) bool {
+func rewriteValuedec64_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpLsh8x64(v *Value) bool {
+func rewriteValuedec64_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpMul64(v *Value) bool {
+func rewriteValuedec64_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpNeg64(v *Value) bool {
+func rewriteValuedec64_OpNeg64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neg64 <t> x)
return true
}
}
-func rewriteValuedec64_OpNeq64(v *Value) bool {
+func rewriteValuedec64_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpOr64(v *Value) bool {
+func rewriteValuedec64_OpOr64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpRsh16Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh16x64(v *Value) bool {
+func rewriteValuedec64_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh32Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh32x64(v *Value) bool {
+func rewriteValuedec64_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64Ux16(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64Ux32(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64Ux8(v *Value) bool {
+func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64x16(v *Value) bool {
+func rewriteValuedec64_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64x32(v *Value) bool {
+func rewriteValuedec64_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64x64(v *Value) bool {
+func rewriteValuedec64_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh64x8(v *Value) bool {
+func rewriteValuedec64_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh8Ux64(v *Value) bool {
+func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpRsh8x64(v *Value) bool {
+func rewriteValuedec64_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuedec64_OpSignExt16to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpSignExt32to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpSignExt8to64(v *Value) bool {
+func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpStore(v *Value) bool {
+func rewriteValuedec64_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuedec64_OpSub64(v *Value) bool {
+func rewriteValuedec64_OpSub64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpTrunc64to16(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 (Int64Make _ lo))
// cond:
// result: (Trunc32to16 lo)
}
return false
}
-func rewriteValuedec64_OpTrunc64to32(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 (Int64Make _ lo))
// cond:
// result: lo
}
return false
}
-func rewriteValuedec64_OpTrunc64to8(v *Value) bool {
+func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 (Int64Make _ lo))
// cond:
// result: (Trunc32to8 lo)
}
return false
}
-func rewriteValuedec64_OpXor64(v *Value) bool {
+func rewriteValuedec64_OpXor64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpZeroExt16to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpZeroExt32to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuedec64_OpZeroExt8to64(v *Value) bool {
+func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
func rewriteValuegeneric(v *Value) bool {
switch v.Op {
case OpAdd16:
- return rewriteValuegeneric_OpAdd16(v)
+ return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v)
case OpAdd32:
- return rewriteValuegeneric_OpAdd32(v)
+ return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v)
case OpAdd32F:
- return rewriteValuegeneric_OpAdd32F(v)
+ return rewriteValuegeneric_OpAdd32F_0(v)
case OpAdd64:
- return rewriteValuegeneric_OpAdd64(v)
+ return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v)
case OpAdd64F:
- return rewriteValuegeneric_OpAdd64F(v)
+ return rewriteValuegeneric_OpAdd64F_0(v)
case OpAdd8:
- return rewriteValuegeneric_OpAdd8(v)
+ return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v)
case OpAddPtr:
- return rewriteValuegeneric_OpAddPtr(v)
+ return rewriteValuegeneric_OpAddPtr_0(v)
case OpAnd16:
- return rewriteValuegeneric_OpAnd16(v)
+ return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v)
case OpAnd32:
- return rewriteValuegeneric_OpAnd32(v)
+ return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v)
case OpAnd64:
- return rewriteValuegeneric_OpAnd64(v)
+ return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v)
case OpAnd8:
- return rewriteValuegeneric_OpAnd8(v)
+ return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v)
case OpArg:
- return rewriteValuegeneric_OpArg(v)
+ return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v)
case OpArraySelect:
- return rewriteValuegeneric_OpArraySelect(v)
+ return rewriteValuegeneric_OpArraySelect_0(v)
case OpCom16:
- return rewriteValuegeneric_OpCom16(v)
+ return rewriteValuegeneric_OpCom16_0(v)
case OpCom32:
- return rewriteValuegeneric_OpCom32(v)
+ return rewriteValuegeneric_OpCom32_0(v)
case OpCom64:
- return rewriteValuegeneric_OpCom64(v)
+ return rewriteValuegeneric_OpCom64_0(v)
case OpCom8:
- return rewriteValuegeneric_OpCom8(v)
+ return rewriteValuegeneric_OpCom8_0(v)
case OpConstInterface:
- return rewriteValuegeneric_OpConstInterface(v)
+ return rewriteValuegeneric_OpConstInterface_0(v)
case OpConstSlice:
- return rewriteValuegeneric_OpConstSlice(v)
+ return rewriteValuegeneric_OpConstSlice_0(v)
case OpConstString:
- return rewriteValuegeneric_OpConstString(v)
+ return rewriteValuegeneric_OpConstString_0(v)
case OpConvert:
- return rewriteValuegeneric_OpConvert(v)
+ return rewriteValuegeneric_OpConvert_0(v)
case OpCvt32Fto64F:
- return rewriteValuegeneric_OpCvt32Fto64F(v)
+ return rewriteValuegeneric_OpCvt32Fto64F_0(v)
case OpCvt64Fto32F:
- return rewriteValuegeneric_OpCvt64Fto32F(v)
+ return rewriteValuegeneric_OpCvt64Fto32F_0(v)
case OpDiv16:
- return rewriteValuegeneric_OpDiv16(v)
+ return rewriteValuegeneric_OpDiv16_0(v)
case OpDiv16u:
- return rewriteValuegeneric_OpDiv16u(v)
+ return rewriteValuegeneric_OpDiv16u_0(v)
case OpDiv32:
- return rewriteValuegeneric_OpDiv32(v)
+ return rewriteValuegeneric_OpDiv32_0(v)
case OpDiv32F:
- return rewriteValuegeneric_OpDiv32F(v)
+ return rewriteValuegeneric_OpDiv32F_0(v)
case OpDiv32u:
- return rewriteValuegeneric_OpDiv32u(v)
+ return rewriteValuegeneric_OpDiv32u_0(v)
case OpDiv64:
- return rewriteValuegeneric_OpDiv64(v)
+ return rewriteValuegeneric_OpDiv64_0(v)
case OpDiv64F:
- return rewriteValuegeneric_OpDiv64F(v)
+ return rewriteValuegeneric_OpDiv64F_0(v)
case OpDiv64u:
- return rewriteValuegeneric_OpDiv64u(v)
+ return rewriteValuegeneric_OpDiv64u_0(v)
case OpDiv8:
- return rewriteValuegeneric_OpDiv8(v)
+ return rewriteValuegeneric_OpDiv8_0(v)
case OpDiv8u:
- return rewriteValuegeneric_OpDiv8u(v)
+ return rewriteValuegeneric_OpDiv8u_0(v)
case OpEq16:
- return rewriteValuegeneric_OpEq16(v)
+ return rewriteValuegeneric_OpEq16_0(v)
case OpEq32:
- return rewriteValuegeneric_OpEq32(v)
+ return rewriteValuegeneric_OpEq32_0(v)
case OpEq64:
- return rewriteValuegeneric_OpEq64(v)
+ return rewriteValuegeneric_OpEq64_0(v)
case OpEq8:
- return rewriteValuegeneric_OpEq8(v)
+ return rewriteValuegeneric_OpEq8_0(v)
case OpEqB:
- return rewriteValuegeneric_OpEqB(v)
+ return rewriteValuegeneric_OpEqB_0(v)
case OpEqInter:
- return rewriteValuegeneric_OpEqInter(v)
+ return rewriteValuegeneric_OpEqInter_0(v)
case OpEqPtr:
- return rewriteValuegeneric_OpEqPtr(v)
+ return rewriteValuegeneric_OpEqPtr_0(v)
case OpEqSlice:
- return rewriteValuegeneric_OpEqSlice(v)
+ return rewriteValuegeneric_OpEqSlice_0(v)
case OpGeq16:
- return rewriteValuegeneric_OpGeq16(v)
+ return rewriteValuegeneric_OpGeq16_0(v)
case OpGeq16U:
- return rewriteValuegeneric_OpGeq16U(v)
+ return rewriteValuegeneric_OpGeq16U_0(v)
case OpGeq32:
- return rewriteValuegeneric_OpGeq32(v)
+ return rewriteValuegeneric_OpGeq32_0(v)
case OpGeq32U:
- return rewriteValuegeneric_OpGeq32U(v)
+ return rewriteValuegeneric_OpGeq32U_0(v)
case OpGeq64:
- return rewriteValuegeneric_OpGeq64(v)
+ return rewriteValuegeneric_OpGeq64_0(v)
case OpGeq64U:
- return rewriteValuegeneric_OpGeq64U(v)
+ return rewriteValuegeneric_OpGeq64U_0(v)
case OpGeq8:
- return rewriteValuegeneric_OpGeq8(v)
+ return rewriteValuegeneric_OpGeq8_0(v)
case OpGeq8U:
- return rewriteValuegeneric_OpGeq8U(v)
+ return rewriteValuegeneric_OpGeq8U_0(v)
case OpGreater16:
- return rewriteValuegeneric_OpGreater16(v)
+ return rewriteValuegeneric_OpGreater16_0(v)
case OpGreater16U:
- return rewriteValuegeneric_OpGreater16U(v)
+ return rewriteValuegeneric_OpGreater16U_0(v)
case OpGreater32:
- return rewriteValuegeneric_OpGreater32(v)
+ return rewriteValuegeneric_OpGreater32_0(v)
case OpGreater32U:
- return rewriteValuegeneric_OpGreater32U(v)
+ return rewriteValuegeneric_OpGreater32U_0(v)
case OpGreater64:
- return rewriteValuegeneric_OpGreater64(v)
+ return rewriteValuegeneric_OpGreater64_0(v)
case OpGreater64U:
- return rewriteValuegeneric_OpGreater64U(v)
+ return rewriteValuegeneric_OpGreater64U_0(v)
case OpGreater8:
- return rewriteValuegeneric_OpGreater8(v)
+ return rewriteValuegeneric_OpGreater8_0(v)
case OpGreater8U:
- return rewriteValuegeneric_OpGreater8U(v)
+ return rewriteValuegeneric_OpGreater8U_0(v)
case OpIMake:
- return rewriteValuegeneric_OpIMake(v)
+ return rewriteValuegeneric_OpIMake_0(v)
case OpInterCall:
- return rewriteValuegeneric_OpInterCall(v)
+ return rewriteValuegeneric_OpInterCall_0(v)
case OpIsInBounds:
- return rewriteValuegeneric_OpIsInBounds(v)
+ return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v)
case OpIsNonNil:
- return rewriteValuegeneric_OpIsNonNil(v)
+ return rewriteValuegeneric_OpIsNonNil_0(v)
case OpIsSliceInBounds:
- return rewriteValuegeneric_OpIsSliceInBounds(v)
+ return rewriteValuegeneric_OpIsSliceInBounds_0(v)
case OpLeq16:
- return rewriteValuegeneric_OpLeq16(v)
+ return rewriteValuegeneric_OpLeq16_0(v)
case OpLeq16U:
- return rewriteValuegeneric_OpLeq16U(v)
+ return rewriteValuegeneric_OpLeq16U_0(v)
case OpLeq32:
- return rewriteValuegeneric_OpLeq32(v)
+ return rewriteValuegeneric_OpLeq32_0(v)
case OpLeq32U:
- return rewriteValuegeneric_OpLeq32U(v)
+ return rewriteValuegeneric_OpLeq32U_0(v)
case OpLeq64:
- return rewriteValuegeneric_OpLeq64(v)
+ return rewriteValuegeneric_OpLeq64_0(v)
case OpLeq64U:
- return rewriteValuegeneric_OpLeq64U(v)
+ return rewriteValuegeneric_OpLeq64U_0(v)
case OpLeq8:
- return rewriteValuegeneric_OpLeq8(v)
+ return rewriteValuegeneric_OpLeq8_0(v)
case OpLeq8U:
- return rewriteValuegeneric_OpLeq8U(v)
+ return rewriteValuegeneric_OpLeq8U_0(v)
case OpLess16:
- return rewriteValuegeneric_OpLess16(v)
+ return rewriteValuegeneric_OpLess16_0(v)
case OpLess16U:
- return rewriteValuegeneric_OpLess16U(v)
+ return rewriteValuegeneric_OpLess16U_0(v)
case OpLess32:
- return rewriteValuegeneric_OpLess32(v)
+ return rewriteValuegeneric_OpLess32_0(v)
case OpLess32U:
- return rewriteValuegeneric_OpLess32U(v)
+ return rewriteValuegeneric_OpLess32U_0(v)
case OpLess64:
- return rewriteValuegeneric_OpLess64(v)
+ return rewriteValuegeneric_OpLess64_0(v)
case OpLess64U:
- return rewriteValuegeneric_OpLess64U(v)
+ return rewriteValuegeneric_OpLess64U_0(v)
case OpLess8:
- return rewriteValuegeneric_OpLess8(v)
+ return rewriteValuegeneric_OpLess8_0(v)
case OpLess8U:
- return rewriteValuegeneric_OpLess8U(v)
+ return rewriteValuegeneric_OpLess8U_0(v)
case OpLoad:
- return rewriteValuegeneric_OpLoad(v)
+ return rewriteValuegeneric_OpLoad_0(v)
case OpLsh16x16:
- return rewriteValuegeneric_OpLsh16x16(v)
+ return rewriteValuegeneric_OpLsh16x16_0(v)
case OpLsh16x32:
- return rewriteValuegeneric_OpLsh16x32(v)
+ return rewriteValuegeneric_OpLsh16x32_0(v)
case OpLsh16x64:
- return rewriteValuegeneric_OpLsh16x64(v)
+ return rewriteValuegeneric_OpLsh16x64_0(v)
case OpLsh16x8:
- return rewriteValuegeneric_OpLsh16x8(v)
+ return rewriteValuegeneric_OpLsh16x8_0(v)
case OpLsh32x16:
- return rewriteValuegeneric_OpLsh32x16(v)
+ return rewriteValuegeneric_OpLsh32x16_0(v)
case OpLsh32x32:
- return rewriteValuegeneric_OpLsh32x32(v)
+ return rewriteValuegeneric_OpLsh32x32_0(v)
case OpLsh32x64:
- return rewriteValuegeneric_OpLsh32x64(v)
+ return rewriteValuegeneric_OpLsh32x64_0(v)
case OpLsh32x8:
- return rewriteValuegeneric_OpLsh32x8(v)
+ return rewriteValuegeneric_OpLsh32x8_0(v)
case OpLsh64x16:
- return rewriteValuegeneric_OpLsh64x16(v)
+ return rewriteValuegeneric_OpLsh64x16_0(v)
case OpLsh64x32:
- return rewriteValuegeneric_OpLsh64x32(v)
+ return rewriteValuegeneric_OpLsh64x32_0(v)
case OpLsh64x64:
- return rewriteValuegeneric_OpLsh64x64(v)
+ return rewriteValuegeneric_OpLsh64x64_0(v)
case OpLsh64x8:
- return rewriteValuegeneric_OpLsh64x8(v)
+ return rewriteValuegeneric_OpLsh64x8_0(v)
case OpLsh8x16:
- return rewriteValuegeneric_OpLsh8x16(v)
+ return rewriteValuegeneric_OpLsh8x16_0(v)
case OpLsh8x32:
- return rewriteValuegeneric_OpLsh8x32(v)
+ return rewriteValuegeneric_OpLsh8x32_0(v)
case OpLsh8x64:
- return rewriteValuegeneric_OpLsh8x64(v)
+ return rewriteValuegeneric_OpLsh8x64_0(v)
case OpLsh8x8:
- return rewriteValuegeneric_OpLsh8x8(v)
+ return rewriteValuegeneric_OpLsh8x8_0(v)
case OpMod16:
- return rewriteValuegeneric_OpMod16(v)
+ return rewriteValuegeneric_OpMod16_0(v)
case OpMod16u:
- return rewriteValuegeneric_OpMod16u(v)
+ return rewriteValuegeneric_OpMod16u_0(v)
case OpMod32:
- return rewriteValuegeneric_OpMod32(v)
+ return rewriteValuegeneric_OpMod32_0(v)
case OpMod32u:
- return rewriteValuegeneric_OpMod32u(v)
+ return rewriteValuegeneric_OpMod32u_0(v)
case OpMod64:
- return rewriteValuegeneric_OpMod64(v)
+ return rewriteValuegeneric_OpMod64_0(v)
case OpMod64u:
- return rewriteValuegeneric_OpMod64u(v)
+ return rewriteValuegeneric_OpMod64u_0(v)
case OpMod8:
- return rewriteValuegeneric_OpMod8(v)
+ return rewriteValuegeneric_OpMod8_0(v)
case OpMod8u:
- return rewriteValuegeneric_OpMod8u(v)
+ return rewriteValuegeneric_OpMod8u_0(v)
case OpMul16:
- return rewriteValuegeneric_OpMul16(v)
+ return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v)
case OpMul32:
- return rewriteValuegeneric_OpMul32(v)
+ return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v)
case OpMul32F:
- return rewriteValuegeneric_OpMul32F(v)
+ return rewriteValuegeneric_OpMul32F_0(v)
case OpMul64:
- return rewriteValuegeneric_OpMul64(v)
+ return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v)
case OpMul64F:
- return rewriteValuegeneric_OpMul64F(v)
+ return rewriteValuegeneric_OpMul64F_0(v)
case OpMul8:
- return rewriteValuegeneric_OpMul8(v)
+ return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v)
case OpNeg16:
- return rewriteValuegeneric_OpNeg16(v)
+ return rewriteValuegeneric_OpNeg16_0(v)
case OpNeg32:
- return rewriteValuegeneric_OpNeg32(v)
+ return rewriteValuegeneric_OpNeg32_0(v)
case OpNeg32F:
- return rewriteValuegeneric_OpNeg32F(v)
+ return rewriteValuegeneric_OpNeg32F_0(v)
case OpNeg64:
- return rewriteValuegeneric_OpNeg64(v)
+ return rewriteValuegeneric_OpNeg64_0(v)
case OpNeg64F:
- return rewriteValuegeneric_OpNeg64F(v)
+ return rewriteValuegeneric_OpNeg64F_0(v)
case OpNeg8:
- return rewriteValuegeneric_OpNeg8(v)
+ return rewriteValuegeneric_OpNeg8_0(v)
case OpNeq16:
- return rewriteValuegeneric_OpNeq16(v)
+ return rewriteValuegeneric_OpNeq16_0(v)
case OpNeq32:
- return rewriteValuegeneric_OpNeq32(v)
+ return rewriteValuegeneric_OpNeq32_0(v)
case OpNeq64:
- return rewriteValuegeneric_OpNeq64(v)
+ return rewriteValuegeneric_OpNeq64_0(v)
case OpNeq8:
- return rewriteValuegeneric_OpNeq8(v)
+ return rewriteValuegeneric_OpNeq8_0(v)
case OpNeqB:
- return rewriteValuegeneric_OpNeqB(v)
+ return rewriteValuegeneric_OpNeqB_0(v)
case OpNeqInter:
- return rewriteValuegeneric_OpNeqInter(v)
+ return rewriteValuegeneric_OpNeqInter_0(v)
case OpNeqPtr:
- return rewriteValuegeneric_OpNeqPtr(v)
+ return rewriteValuegeneric_OpNeqPtr_0(v)
case OpNeqSlice:
- return rewriteValuegeneric_OpNeqSlice(v)
+ return rewriteValuegeneric_OpNeqSlice_0(v)
case OpNilCheck:
- return rewriteValuegeneric_OpNilCheck(v)
+ return rewriteValuegeneric_OpNilCheck_0(v)
case OpNot:
- return rewriteValuegeneric_OpNot(v)
+ return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v)
case OpOffPtr:
- return rewriteValuegeneric_OpOffPtr(v)
+ return rewriteValuegeneric_OpOffPtr_0(v)
case OpOr16:
- return rewriteValuegeneric_OpOr16(v)
+ return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v)
case OpOr32:
- return rewriteValuegeneric_OpOr32(v)
+ return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v)
case OpOr64:
- return rewriteValuegeneric_OpOr64(v)
+ return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v)
case OpOr8:
- return rewriteValuegeneric_OpOr8(v)
+ return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v)
case OpPhi:
- return rewriteValuegeneric_OpPhi(v)
+ return rewriteValuegeneric_OpPhi_0(v)
case OpPtrIndex:
- return rewriteValuegeneric_OpPtrIndex(v)
+ return rewriteValuegeneric_OpPtrIndex_0(v)
case OpRound32F:
- return rewriteValuegeneric_OpRound32F(v)
+ return rewriteValuegeneric_OpRound32F_0(v)
case OpRound64F:
- return rewriteValuegeneric_OpRound64F(v)
+ return rewriteValuegeneric_OpRound64F_0(v)
case OpRsh16Ux16:
- return rewriteValuegeneric_OpRsh16Ux16(v)
+ return rewriteValuegeneric_OpRsh16Ux16_0(v)
case OpRsh16Ux32:
- return rewriteValuegeneric_OpRsh16Ux32(v)
+ return rewriteValuegeneric_OpRsh16Ux32_0(v)
case OpRsh16Ux64:
- return rewriteValuegeneric_OpRsh16Ux64(v)
+ return rewriteValuegeneric_OpRsh16Ux64_0(v)
case OpRsh16Ux8:
- return rewriteValuegeneric_OpRsh16Ux8(v)
+ return rewriteValuegeneric_OpRsh16Ux8_0(v)
case OpRsh16x16:
- return rewriteValuegeneric_OpRsh16x16(v)
+ return rewriteValuegeneric_OpRsh16x16_0(v)
case OpRsh16x32:
- return rewriteValuegeneric_OpRsh16x32(v)
+ return rewriteValuegeneric_OpRsh16x32_0(v)
case OpRsh16x64:
- return rewriteValuegeneric_OpRsh16x64(v)
+ return rewriteValuegeneric_OpRsh16x64_0(v)
case OpRsh16x8:
- return rewriteValuegeneric_OpRsh16x8(v)
+ return rewriteValuegeneric_OpRsh16x8_0(v)
case OpRsh32Ux16:
- return rewriteValuegeneric_OpRsh32Ux16(v)
+ return rewriteValuegeneric_OpRsh32Ux16_0(v)
case OpRsh32Ux32:
- return rewriteValuegeneric_OpRsh32Ux32(v)
+ return rewriteValuegeneric_OpRsh32Ux32_0(v)
case OpRsh32Ux64:
- return rewriteValuegeneric_OpRsh32Ux64(v)
+ return rewriteValuegeneric_OpRsh32Ux64_0(v)
case OpRsh32Ux8:
- return rewriteValuegeneric_OpRsh32Ux8(v)
+ return rewriteValuegeneric_OpRsh32Ux8_0(v)
case OpRsh32x16:
- return rewriteValuegeneric_OpRsh32x16(v)
+ return rewriteValuegeneric_OpRsh32x16_0(v)
case OpRsh32x32:
- return rewriteValuegeneric_OpRsh32x32(v)
+ return rewriteValuegeneric_OpRsh32x32_0(v)
case OpRsh32x64:
- return rewriteValuegeneric_OpRsh32x64(v)
+ return rewriteValuegeneric_OpRsh32x64_0(v)
case OpRsh32x8:
- return rewriteValuegeneric_OpRsh32x8(v)
+ return rewriteValuegeneric_OpRsh32x8_0(v)
case OpRsh64Ux16:
- return rewriteValuegeneric_OpRsh64Ux16(v)
+ return rewriteValuegeneric_OpRsh64Ux16_0(v)
case OpRsh64Ux32:
- return rewriteValuegeneric_OpRsh64Ux32(v)
+ return rewriteValuegeneric_OpRsh64Ux32_0(v)
case OpRsh64Ux64:
- return rewriteValuegeneric_OpRsh64Ux64(v)
+ return rewriteValuegeneric_OpRsh64Ux64_0(v)
case OpRsh64Ux8:
- return rewriteValuegeneric_OpRsh64Ux8(v)
+ return rewriteValuegeneric_OpRsh64Ux8_0(v)
case OpRsh64x16:
- return rewriteValuegeneric_OpRsh64x16(v)
+ return rewriteValuegeneric_OpRsh64x16_0(v)
case OpRsh64x32:
- return rewriteValuegeneric_OpRsh64x32(v)
+ return rewriteValuegeneric_OpRsh64x32_0(v)
case OpRsh64x64:
- return rewriteValuegeneric_OpRsh64x64(v)
+ return rewriteValuegeneric_OpRsh64x64_0(v)
case OpRsh64x8:
- return rewriteValuegeneric_OpRsh64x8(v)
+ return rewriteValuegeneric_OpRsh64x8_0(v)
case OpRsh8Ux16:
- return rewriteValuegeneric_OpRsh8Ux16(v)
+ return rewriteValuegeneric_OpRsh8Ux16_0(v)
case OpRsh8Ux32:
- return rewriteValuegeneric_OpRsh8Ux32(v)
+ return rewriteValuegeneric_OpRsh8Ux32_0(v)
case OpRsh8Ux64:
- return rewriteValuegeneric_OpRsh8Ux64(v)
+ return rewriteValuegeneric_OpRsh8Ux64_0(v)
case OpRsh8Ux8:
- return rewriteValuegeneric_OpRsh8Ux8(v)
+ return rewriteValuegeneric_OpRsh8Ux8_0(v)
case OpRsh8x16:
- return rewriteValuegeneric_OpRsh8x16(v)
+ return rewriteValuegeneric_OpRsh8x16_0(v)
case OpRsh8x32:
- return rewriteValuegeneric_OpRsh8x32(v)
+ return rewriteValuegeneric_OpRsh8x32_0(v)
case OpRsh8x64:
- return rewriteValuegeneric_OpRsh8x64(v)
+ return rewriteValuegeneric_OpRsh8x64_0(v)
case OpRsh8x8:
- return rewriteValuegeneric_OpRsh8x8(v)
+ return rewriteValuegeneric_OpRsh8x8_0(v)
case OpSignExt16to32:
- return rewriteValuegeneric_OpSignExt16to32(v)
+ return rewriteValuegeneric_OpSignExt16to32_0(v)
case OpSignExt16to64:
- return rewriteValuegeneric_OpSignExt16to64(v)
+ return rewriteValuegeneric_OpSignExt16to64_0(v)
case OpSignExt32to64:
- return rewriteValuegeneric_OpSignExt32to64(v)
+ return rewriteValuegeneric_OpSignExt32to64_0(v)
case OpSignExt8to16:
- return rewriteValuegeneric_OpSignExt8to16(v)
+ return rewriteValuegeneric_OpSignExt8to16_0(v)
case OpSignExt8to32:
- return rewriteValuegeneric_OpSignExt8to32(v)
+ return rewriteValuegeneric_OpSignExt8to32_0(v)
case OpSignExt8to64:
- return rewriteValuegeneric_OpSignExt8to64(v)
+ return rewriteValuegeneric_OpSignExt8to64_0(v)
case OpSliceCap:
- return rewriteValuegeneric_OpSliceCap(v)
+ return rewriteValuegeneric_OpSliceCap_0(v)
case OpSliceLen:
- return rewriteValuegeneric_OpSliceLen(v)
+ return rewriteValuegeneric_OpSliceLen_0(v)
case OpSlicePtr:
- return rewriteValuegeneric_OpSlicePtr(v)
+ return rewriteValuegeneric_OpSlicePtr_0(v)
case OpSlicemask:
- return rewriteValuegeneric_OpSlicemask(v)
+ return rewriteValuegeneric_OpSlicemask_0(v)
case OpSqrt:
- return rewriteValuegeneric_OpSqrt(v)
+ return rewriteValuegeneric_OpSqrt_0(v)
case OpStore:
- return rewriteValuegeneric_OpStore(v)
+ return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v)
case OpStringLen:
- return rewriteValuegeneric_OpStringLen(v)
+ return rewriteValuegeneric_OpStringLen_0(v)
case OpStringPtr:
- return rewriteValuegeneric_OpStringPtr(v)
+ return rewriteValuegeneric_OpStringPtr_0(v)
case OpStructSelect:
- return rewriteValuegeneric_OpStructSelect(v)
+ return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v)
case OpSub16:
- return rewriteValuegeneric_OpSub16(v)
+ return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v)
case OpSub32:
- return rewriteValuegeneric_OpSub32(v)
+ return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v)
case OpSub32F:
- return rewriteValuegeneric_OpSub32F(v)
+ return rewriteValuegeneric_OpSub32F_0(v)
case OpSub64:
- return rewriteValuegeneric_OpSub64(v)
+ return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v)
case OpSub64F:
- return rewriteValuegeneric_OpSub64F(v)
+ return rewriteValuegeneric_OpSub64F_0(v)
case OpSub8:
- return rewriteValuegeneric_OpSub8(v)
+ return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v)
case OpTrunc16to8:
- return rewriteValuegeneric_OpTrunc16to8(v)
+ return rewriteValuegeneric_OpTrunc16to8_0(v)
case OpTrunc32to16:
- return rewriteValuegeneric_OpTrunc32to16(v)
+ return rewriteValuegeneric_OpTrunc32to16_0(v)
case OpTrunc32to8:
- return rewriteValuegeneric_OpTrunc32to8(v)
+ return rewriteValuegeneric_OpTrunc32to8_0(v)
case OpTrunc64to16:
- return rewriteValuegeneric_OpTrunc64to16(v)
+ return rewriteValuegeneric_OpTrunc64to16_0(v)
case OpTrunc64to32:
- return rewriteValuegeneric_OpTrunc64to32(v)
+ return rewriteValuegeneric_OpTrunc64to32_0(v)
case OpTrunc64to8:
- return rewriteValuegeneric_OpTrunc64to8(v)
+ return rewriteValuegeneric_OpTrunc64to8_0(v)
case OpXor16:
- return rewriteValuegeneric_OpXor16(v)
+ return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v)
case OpXor32:
- return rewriteValuegeneric_OpXor32(v)
+ return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v)
case OpXor64:
- return rewriteValuegeneric_OpXor64(v)
+ return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v)
case OpXor8:
- return rewriteValuegeneric_OpXor8(v)
+ return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v)
case OpZero:
- return rewriteValuegeneric_OpZero(v)
+ return rewriteValuegeneric_OpZero_0(v)
case OpZeroExt16to32:
- return rewriteValuegeneric_OpZeroExt16to32(v)
+ return rewriteValuegeneric_OpZeroExt16to32_0(v)
case OpZeroExt16to64:
- return rewriteValuegeneric_OpZeroExt16to64(v)
+ return rewriteValuegeneric_OpZeroExt16to64_0(v)
case OpZeroExt32to64:
- return rewriteValuegeneric_OpZeroExt32to64(v)
+ return rewriteValuegeneric_OpZeroExt32to64_0(v)
case OpZeroExt8to16:
- return rewriteValuegeneric_OpZeroExt8to16(v)
+ return rewriteValuegeneric_OpZeroExt8to16_0(v)
case OpZeroExt8to32:
- return rewriteValuegeneric_OpZeroExt8to32(v)
+ return rewriteValuegeneric_OpZeroExt8to32_0(v)
case OpZeroExt8to64:
- return rewriteValuegeneric_OpZeroExt8to64(v)
+ return rewriteValuegeneric_OpZeroExt8to64_0(v)
}
return false
}
-func rewriteValuegeneric_OpAdd16(v *Value) bool {
+func rewriteValuegeneric_OpAdd16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add16 (Const16 [c]) (Const16 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add16 (Sub16 i:(Const16 <t>) z) x)
// cond: (z.Op != OpConst16 && x.Op != OpConst16)
// result: (Add16 i (Sub16 <t> x z))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd16_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add16 (Add16 (Const16 <t> [d]) x) (Const16 <t> [c]))
// cond:
// result: (Add16 (Const16 <t> [int64(int16(c+d))]) x)
}
return false
}
-func rewriteValuegeneric_OpAdd32(v *Value) bool {
+func rewriteValuegeneric_OpAdd32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add32 (Const32 [c]) (Const32 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add32 (Sub32 i:(Const32 <t>) z) x)
// cond: (z.Op != OpConst32 && x.Op != OpConst32)
// result: (Add32 i (Sub32 <t> x z))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd32_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add32 (Add32 (Const32 <t> [d]) x) (Const32 <t> [c]))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c+d))]) x)
}
return false
}
-func rewriteValuegeneric_OpAdd32F(v *Value) bool {
+func rewriteValuegeneric_OpAdd32F_0(v *Value) bool {
// match: (Add32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))])
}
return false
}
-func rewriteValuegeneric_OpAdd64(v *Value) bool {
+func rewriteValuegeneric_OpAdd64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add64 (Const64 [c]) (Const64 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add64 (Sub64 i:(Const64 <t>) z) x)
// cond: (z.Op != OpConst64 && x.Op != OpConst64)
// result: (Add64 i (Sub64 <t> x z))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd64_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add64 (Add64 (Const64 <t> [d]) x) (Const64 <t> [c]))
// cond:
// result: (Add64 (Const64 <t> [c+d]) x)
}
return false
}
-func rewriteValuegeneric_OpAdd64F(v *Value) bool {
+func rewriteValuegeneric_OpAdd64F_0(v *Value) bool {
// match: (Add64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) + i2f(d))])
}
return false
}
-func rewriteValuegeneric_OpAdd8(v *Value) bool {
+func rewriteValuegeneric_OpAdd8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Add8 (Const8 [c]) (Const8 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add8 (Sub8 i:(Const8 <t>) z) x)
// cond: (z.Op != OpConst8 && x.Op != OpConst8)
// result: (Add8 i (Sub8 <t> x z))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAdd8_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Add8 (Add8 (Const8 <t> [d]) x) (Const8 <t> [c]))
// cond:
// result: (Add8 (Const8 <t> [int64(int8(c+d))]) x)
}
return false
}
-func rewriteValuegeneric_OpAddPtr(v *Value) bool {
+func rewriteValuegeneric_OpAddPtr_0(v *Value) bool {
// match: (AddPtr <t> x (Const64 [c]))
// cond:
// result: (OffPtr <t> x [c])
}
return false
}
-func rewriteValuegeneric_OpAnd16(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpAnd16_0(v *Value) bool {
// match: (And16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [int64(int16(c&d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAnd16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (And16 (And16 y x) x)
// cond:
// result: (And16 x y)
}
return false
}
-func rewriteValuegeneric_OpAnd32(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpAnd32_0(v *Value) bool {
// match: (And32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [int64(int32(c&d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAnd32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (And32 (And32 y x) x)
// cond:
// result: (And32 x y)
}
return false
}
-func rewriteValuegeneric_OpAnd64(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpAnd64_0(v *Value) bool {
// match: (And64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c&d])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAnd64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (And64 (And64 y x) x)
// cond:
// result: (And64 x y)
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAnd64_20(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (And64 (Const64 <t> [c]) (And64 x (Const64 <t> [d])))
// cond:
// result: (And64 (Const64 <t> [c&d]) x)
}
return false
}
-func rewriteValuegeneric_OpAnd8(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpAnd8_0(v *Value) bool {
// match: (And8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [int64(int8(c&d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpAnd8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (And8 (And8 y x) x)
// cond:
// result: (And8 x y)
}
return false
}
-func rewriteValuegeneric_OpArg(v *Value) bool {
+func rewriteValuegeneric_OpArg_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
v.AddArg(v3)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpArg_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ fe := b.Func.fe
+ _ = fe
// match: (Arg <t>)
// cond: t.IsArray() && t.NumElem() == 0
// result: (ArrayMake0)
}
return false
}
-func rewriteValuegeneric_OpArraySelect(v *Value) bool {
+func rewriteValuegeneric_OpArraySelect_0(v *Value) bool {
// match: (ArraySelect (ArrayMake1 x))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpCom16(v *Value) bool {
+func rewriteValuegeneric_OpCom16_0(v *Value) bool {
// match: (Com16 (Com16 x))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpCom32(v *Value) bool {
+func rewriteValuegeneric_OpCom32_0(v *Value) bool {
// match: (Com32 (Com32 x))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpCom64(v *Value) bool {
+func rewriteValuegeneric_OpCom64_0(v *Value) bool {
// match: (Com64 (Com64 x))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpCom8(v *Value) bool {
+func rewriteValuegeneric_OpCom8_0(v *Value) bool {
// match: (Com8 (Com8 x))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpConstInterface(v *Value) bool {
+func rewriteValuegeneric_OpConstInterface_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuegeneric_OpConstSlice(v *Value) bool {
+func rewriteValuegeneric_OpConstSlice_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpConstString(v *Value) bool {
+func rewriteValuegeneric_OpConstString_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpConvert(v *Value) bool {
+func rewriteValuegeneric_OpConvert_0(v *Value) bool {
// match: (Convert (Add64 (Convert ptr mem) off) mem)
// cond:
// result: (Add64 ptr off)
}
return false
}
-func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool {
+func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool {
// match: (Cvt32Fto64F (Const32F [c]))
// cond:
// result: (Const64F [c])
}
return false
}
-func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool {
+func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool {
// match: (Cvt64Fto32F (Const64F [c]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c)))])
}
return false
}
-func rewriteValuegeneric_OpDiv16(v *Value) bool {
+func rewriteValuegeneric_OpDiv16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpDiv16u(v *Value) bool {
+func rewriteValuegeneric_OpDiv16u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpDiv32(v *Value) bool {
+func rewriteValuegeneric_OpDiv32_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpDiv32F(v *Value) bool {
+func rewriteValuegeneric_OpDiv32F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Div32F (Const32F [c]) (Const32F [d]))
}
return false
}
-func rewriteValuegeneric_OpDiv32u(v *Value) bool {
+func rewriteValuegeneric_OpDiv32u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpDiv64(v *Value) bool {
+func rewriteValuegeneric_OpDiv64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpDiv64F(v *Value) bool {
+func rewriteValuegeneric_OpDiv64F_0(v *Value) bool {
b := v.Block
_ = b
// match: (Div64F (Const64F [c]) (Const64F [d]))
}
return false
}
-func rewriteValuegeneric_OpDiv64u(v *Value) bool {
+func rewriteValuegeneric_OpDiv64u_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpDiv8(v *Value) bool {
+func rewriteValuegeneric_OpDiv8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpDiv8u(v *Value) bool {
+func rewriteValuegeneric_OpDiv8u_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpEq16(v *Value) bool {
+func rewriteValuegeneric_OpEq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq16 x x)
}
return false
}
-func rewriteValuegeneric_OpEq32(v *Value) bool {
+func rewriteValuegeneric_OpEq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq32 x x)
}
return false
}
-func rewriteValuegeneric_OpEq64(v *Value) bool {
+func rewriteValuegeneric_OpEq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq64 x x)
}
return false
}
-func rewriteValuegeneric_OpEq8(v *Value) bool {
+func rewriteValuegeneric_OpEq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Eq8 x x)
}
return false
}
-func rewriteValuegeneric_OpEqB(v *Value) bool {
+func rewriteValuegeneric_OpEqB_0(v *Value) bool {
// match: (EqB (ConstBool [c]) (ConstBool [d]))
// cond:
// result: (ConstBool [b2i(c == d)])
}
return false
}
-func rewriteValuegeneric_OpEqInter(v *Value) bool {
+func rewriteValuegeneric_OpEqInter_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuegeneric_OpEqPtr(v *Value) bool {
+func rewriteValuegeneric_OpEqPtr_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpEqSlice(v *Value) bool {
+func rewriteValuegeneric_OpEqSlice_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuegeneric_OpGeq16(v *Value) bool {
+func rewriteValuegeneric_OpGeq16_0(v *Value) bool {
// match: (Geq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
}
return false
}
-func rewriteValuegeneric_OpGeq16U(v *Value) bool {
+func rewriteValuegeneric_OpGeq16U_0(v *Value) bool {
// match: (Geq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) >= uint16(d))])
}
return false
}
-func rewriteValuegeneric_OpGeq32(v *Value) bool {
+func rewriteValuegeneric_OpGeq32_0(v *Value) bool {
// match: (Geq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
}
return false
}
-func rewriteValuegeneric_OpGeq32U(v *Value) bool {
+func rewriteValuegeneric_OpGeq32U_0(v *Value) bool {
// match: (Geq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) >= uint32(d))])
}
return false
}
-func rewriteValuegeneric_OpGeq64(v *Value) bool {
+func rewriteValuegeneric_OpGeq64_0(v *Value) bool {
// match: (Geq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
}
return false
}
-func rewriteValuegeneric_OpGeq64U(v *Value) bool {
+func rewriteValuegeneric_OpGeq64U_0(v *Value) bool {
// match: (Geq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) >= uint64(d))])
}
return false
}
-func rewriteValuegeneric_OpGeq8(v *Value) bool {
+func rewriteValuegeneric_OpGeq8_0(v *Value) bool {
// match: (Geq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c >= d)])
}
return false
}
-func rewriteValuegeneric_OpGeq8U(v *Value) bool {
+func rewriteValuegeneric_OpGeq8U_0(v *Value) bool {
// match: (Geq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) >= uint8(d))])
}
return false
}
-func rewriteValuegeneric_OpGreater16(v *Value) bool {
+func rewriteValuegeneric_OpGreater16_0(v *Value) bool {
// match: (Greater16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
}
return false
}
-func rewriteValuegeneric_OpGreater16U(v *Value) bool {
+func rewriteValuegeneric_OpGreater16U_0(v *Value) bool {
// match: (Greater16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) > uint16(d))])
}
return false
}
-func rewriteValuegeneric_OpGreater32(v *Value) bool {
+func rewriteValuegeneric_OpGreater32_0(v *Value) bool {
// match: (Greater32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
}
return false
}
-func rewriteValuegeneric_OpGreater32U(v *Value) bool {
+func rewriteValuegeneric_OpGreater32U_0(v *Value) bool {
// match: (Greater32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) > uint32(d))])
}
return false
}
-func rewriteValuegeneric_OpGreater64(v *Value) bool {
+func rewriteValuegeneric_OpGreater64_0(v *Value) bool {
// match: (Greater64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
}
return false
}
-func rewriteValuegeneric_OpGreater64U(v *Value) bool {
+func rewriteValuegeneric_OpGreater64U_0(v *Value) bool {
// match: (Greater64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) > uint64(d))])
}
return false
}
-func rewriteValuegeneric_OpGreater8(v *Value) bool {
+func rewriteValuegeneric_OpGreater8_0(v *Value) bool {
// match: (Greater8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c > d)])
}
return false
}
-func rewriteValuegeneric_OpGreater8U(v *Value) bool {
+func rewriteValuegeneric_OpGreater8U_0(v *Value) bool {
// match: (Greater8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) > uint8(d))])
}
return false
}
-func rewriteValuegeneric_OpIMake(v *Value) bool {
+func rewriteValuegeneric_OpIMake_0(v *Value) bool {
// match: (IMake typ (StructMake1 val))
// cond:
// result: (IMake typ val)
}
return false
}
-func rewriteValuegeneric_OpInterCall(v *Value) bool {
+func rewriteValuegeneric_OpInterCall_0(v *Value) bool {
// match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem)
// cond: devirt(v, itab, off) != nil
// result: (StaticCall [argsize] {devirt(v, itab, off)} mem)
}
return false
}
-func rewriteValuegeneric_OpIsInBounds(v *Value) bool {
+func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool {
// match: (IsInBounds (ZeroExt8to32 _) (Const32 [c]))
// cond: (1 << 8) <= c
// result: (ConstBool [1])
v.AuxInt = 1
return true
}
+ return false
+}
+func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool {
// match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d]))
// cond: 0 <= c && c < d
// result: (ConstBool [1])
v.AuxInt = 1
return true
}
+ return false
+}
+func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool {
// match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d]))
// cond: 0 <= c && c < d
// result: (ConstBool [1])
}
return false
}
-func rewriteValuegeneric_OpIsNonNil(v *Value) bool {
+func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool {
// match: (IsNonNil (ConstNil))
// cond:
// result: (ConstBool [0])
}
return false
}
-func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool {
+func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool {
// match: (IsSliceInBounds x x)
// cond:
// result: (ConstBool [1])
}
return false
}
-func rewriteValuegeneric_OpLeq16(v *Value) bool {
+func rewriteValuegeneric_OpLeq16_0(v *Value) bool {
// match: (Leq16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
}
return false
}
-func rewriteValuegeneric_OpLeq16U(v *Value) bool {
+func rewriteValuegeneric_OpLeq16U_0(v *Value) bool {
// match: (Leq16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) <= uint16(d))])
}
return false
}
-func rewriteValuegeneric_OpLeq32(v *Value) bool {
+func rewriteValuegeneric_OpLeq32_0(v *Value) bool {
// match: (Leq32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
}
return false
}
-func rewriteValuegeneric_OpLeq32U(v *Value) bool {
+func rewriteValuegeneric_OpLeq32U_0(v *Value) bool {
// match: (Leq32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) <= uint32(d))])
}
return false
}
-func rewriteValuegeneric_OpLeq64(v *Value) bool {
+func rewriteValuegeneric_OpLeq64_0(v *Value) bool {
// match: (Leq64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
}
return false
}
-func rewriteValuegeneric_OpLeq64U(v *Value) bool {
+func rewriteValuegeneric_OpLeq64U_0(v *Value) bool {
// match: (Leq64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) <= uint64(d))])
}
return false
}
-func rewriteValuegeneric_OpLeq8(v *Value) bool {
+func rewriteValuegeneric_OpLeq8_0(v *Value) bool {
// match: (Leq8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c <= d)])
}
return false
}
-func rewriteValuegeneric_OpLeq8U(v *Value) bool {
+func rewriteValuegeneric_OpLeq8U_0(v *Value) bool {
// match: (Leq8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) <= uint8(d))])
}
return false
}
-func rewriteValuegeneric_OpLess16(v *Value) bool {
+func rewriteValuegeneric_OpLess16_0(v *Value) bool {
// match: (Less16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
}
return false
}
-func rewriteValuegeneric_OpLess16U(v *Value) bool {
+func rewriteValuegeneric_OpLess16U_0(v *Value) bool {
// match: (Less16U (Const16 [c]) (Const16 [d]))
// cond:
// result: (ConstBool [b2i(uint16(c) < uint16(d))])
}
return false
}
-func rewriteValuegeneric_OpLess32(v *Value) bool {
+func rewriteValuegeneric_OpLess32_0(v *Value) bool {
// match: (Less32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
}
return false
}
-func rewriteValuegeneric_OpLess32U(v *Value) bool {
+func rewriteValuegeneric_OpLess32U_0(v *Value) bool {
// match: (Less32U (Const32 [c]) (Const32 [d]))
// cond:
// result: (ConstBool [b2i(uint32(c) < uint32(d))])
}
return false
}
-func rewriteValuegeneric_OpLess64(v *Value) bool {
+func rewriteValuegeneric_OpLess64_0(v *Value) bool {
// match: (Less64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
}
return false
}
-func rewriteValuegeneric_OpLess64U(v *Value) bool {
+func rewriteValuegeneric_OpLess64U_0(v *Value) bool {
// match: (Less64U (Const64 [c]) (Const64 [d]))
// cond:
// result: (ConstBool [b2i(uint64(c) < uint64(d))])
}
return false
}
-func rewriteValuegeneric_OpLess8(v *Value) bool {
+func rewriteValuegeneric_OpLess8_0(v *Value) bool {
// match: (Less8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(c < d)])
}
return false
}
-func rewriteValuegeneric_OpLess8U(v *Value) bool {
+func rewriteValuegeneric_OpLess8U_0(v *Value) bool {
// match: (Less8U (Const8 [c]) (Const8 [d]))
// cond:
// result: (ConstBool [b2i(uint8(c) < uint8(d))])
}
return false
}
-func rewriteValuegeneric_OpLoad(v *Value) bool {
+func rewriteValuegeneric_OpLoad_0(v *Value) bool {
b := v.Block
_ = b
fe := b.Func.fe
}
return false
}
-func rewriteValuegeneric_OpLsh16x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh16x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh16x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpLsh16x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh16x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh32x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh32x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh32x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpLsh32x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh32x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh64x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh64x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh64x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpLsh64x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh64x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh8x16(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh8x32(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpLsh8x64(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpLsh8x8(v *Value) bool {
+func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Lsh8x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpMod16(v *Value) bool {
+func rewriteValuegeneric_OpMod16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod16 (Const16 [c]) (Const16 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod16u(v *Value) bool {
+func rewriteValuegeneric_OpMod16u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod16u (Const16 [c]) (Const16 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod32(v *Value) bool {
+func rewriteValuegeneric_OpMod32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod32 (Const32 [c]) (Const32 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod32u(v *Value) bool {
+func rewriteValuegeneric_OpMod32u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod32u (Const32 [c]) (Const32 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod64(v *Value) bool {
+func rewriteValuegeneric_OpMod64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod64 (Const64 [c]) (Const64 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod64u(v *Value) bool {
+func rewriteValuegeneric_OpMod64u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod64u (Const64 [c]) (Const64 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod8(v *Value) bool {
+func rewriteValuegeneric_OpMod8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod8 (Const8 [c]) (Const8 [d]))
}
return false
}
-func rewriteValuegeneric_OpMod8u(v *Value) bool {
+func rewriteValuegeneric_OpMod8u_0(v *Value) bool {
b := v.Block
_ = b
// match: (Mod8u (Const8 [c]) (Const8 [d]))
}
return false
}
-func rewriteValuegeneric_OpMul16(v *Value) bool {
+func rewriteValuegeneric_OpMul16_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpMul16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Mul16 (Const16 [0]) _)
// cond:
// result: (Const16 [0])
}
return false
}
-func rewriteValuegeneric_OpMul32(v *Value) bool {
+func rewriteValuegeneric_OpMul32_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpMul32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Mul32 (Const32 <t> [c]) (Add32 <t> (Const32 <t> [d]) x))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c*d))]) (Mul32 <t> (Const32 <t> [c]) x))
}
return false
}
-func rewriteValuegeneric_OpMul32F(v *Value) bool {
+func rewriteValuegeneric_OpMul32F_0(v *Value) bool {
// match: (Mul32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))])
}
return false
}
-func rewriteValuegeneric_OpMul64(v *Value) bool {
+func rewriteValuegeneric_OpMul64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpMul64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Mul64 (Const64 <t> [c]) (Add64 <t> (Const64 <t> [d]) x))
// cond:
// result: (Add64 (Const64 <t> [c*d]) (Mul64 <t> (Const64 <t> [c]) x))
}
return false
}
-func rewriteValuegeneric_OpMul64F(v *Value) bool {
+func rewriteValuegeneric_OpMul64F_0(v *Value) bool {
// match: (Mul64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) * i2f(d))])
}
return false
}
-func rewriteValuegeneric_OpMul8(v *Value) bool {
+func rewriteValuegeneric_OpMul8_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpMul8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Mul8 (Const8 [0]) _)
// cond:
// result: (Const8 [0])
}
return false
}
-func rewriteValuegeneric_OpNeg16(v *Value) bool {
+func rewriteValuegeneric_OpNeg16_0(v *Value) bool {
// match: (Neg16 (Const16 [c]))
// cond:
// result: (Const16 [int64(-int16(c))])
}
return false
}
-func rewriteValuegeneric_OpNeg32(v *Value) bool {
+func rewriteValuegeneric_OpNeg32_0(v *Value) bool {
// match: (Neg32 (Const32 [c]))
// cond:
// result: (Const32 [int64(-int32(c))])
}
return false
}
-func rewriteValuegeneric_OpNeg32F(v *Value) bool {
+func rewriteValuegeneric_OpNeg32F_0(v *Value) bool {
// match: (Neg32F (Const32F [c]))
// cond: i2f(c) != 0
// result: (Const32F [f2i(-i2f(c))])
}
return false
}
-func rewriteValuegeneric_OpNeg64(v *Value) bool {
+func rewriteValuegeneric_OpNeg64_0(v *Value) bool {
// match: (Neg64 (Const64 [c]))
// cond:
// result: (Const64 [-c])
}
return false
}
-func rewriteValuegeneric_OpNeg64F(v *Value) bool {
+func rewriteValuegeneric_OpNeg64F_0(v *Value) bool {
// match: (Neg64F (Const64F [c]))
// cond: i2f(c) != 0
// result: (Const64F [f2i(-i2f(c))])
}
return false
}
-func rewriteValuegeneric_OpNeg8(v *Value) bool {
+func rewriteValuegeneric_OpNeg8_0(v *Value) bool {
// match: (Neg8 (Const8 [c]))
// cond:
// result: (Const8 [int64( -int8(c))])
}
return false
}
-func rewriteValuegeneric_OpNeq16(v *Value) bool {
+func rewriteValuegeneric_OpNeq16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq16 x x)
}
return false
}
-func rewriteValuegeneric_OpNeq32(v *Value) bool {
+func rewriteValuegeneric_OpNeq32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq32 x x)
}
return false
}
-func rewriteValuegeneric_OpNeq64(v *Value) bool {
+func rewriteValuegeneric_OpNeq64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq64 x x)
}
return false
}
-func rewriteValuegeneric_OpNeq8(v *Value) bool {
+func rewriteValuegeneric_OpNeq8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Neq8 x x)
}
return false
}
-func rewriteValuegeneric_OpNeqB(v *Value) bool {
+func rewriteValuegeneric_OpNeqB_0(v *Value) bool {
// match: (NeqB (ConstBool [c]) (ConstBool [d]))
// cond:
// result: (ConstBool [b2i(c != d)])
}
return false
}
-func rewriteValuegeneric_OpNeqInter(v *Value) bool {
+func rewriteValuegeneric_OpNeqInter_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuegeneric_OpNeqPtr(v *Value) bool {
+func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool {
// match: (NeqPtr p (ConstNil))
// cond:
// result: (IsNonNil p)
}
return false
}
-func rewriteValuegeneric_OpNeqSlice(v *Value) bool {
+func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
return true
}
}
-func rewriteValuegeneric_OpNilCheck(v *Value) bool {
+func rewriteValuegeneric_OpNilCheck_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpNot(v *Value) bool {
+func rewriteValuegeneric_OpNot_0(v *Value) bool {
// match: (Not (Eq64 x y))
// cond:
// result: (Neq64 x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpNot_10(v *Value) bool {
// match: (Not (Greater64 x y))
// cond:
// result: (Leq64 x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpNot_20(v *Value) bool {
// match: (Not (Geq16 x y))
// cond:
// result: (Less16 x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpNot_30(v *Value) bool {
// match: (Not (Less64U x y))
// cond:
// result: (Geq64U x y)
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpNot_40(v *Value) bool {
// match: (Not (Leq16U x y))
// cond:
// result: (Greater16U x y)
}
return false
}
-func rewriteValuegeneric_OpOffPtr(v *Value) bool {
+func rewriteValuegeneric_OpOffPtr_0(v *Value) bool {
// match: (OffPtr (OffPtr p [b]) [a])
// cond:
// result: (OffPtr p [a+b])
}
return false
}
-func rewriteValuegeneric_OpOr16(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpOr16_0(v *Value) bool {
// match: (Or16 (Const16 [c]) (Const16 [d]))
// cond:
// result: (Const16 [int64(int16(c|d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpOr16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Or16 (Or16 y x) x)
// cond:
// result: (Or16 x y)
}
return false
}
-func rewriteValuegeneric_OpOr32(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpOr32_0(v *Value) bool {
// match: (Or32 (Const32 [c]) (Const32 [d]))
// cond:
// result: (Const32 [int64(int32(c|d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpOr32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Or32 (Or32 y x) x)
// cond:
// result: (Or32 x y)
}
return false
}
-func rewriteValuegeneric_OpOr64(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpOr64_0(v *Value) bool {
// match: (Or64 (Const64 [c]) (Const64 [d]))
// cond:
// result: (Const64 [c|d])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpOr64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Or64 (Or64 y x) x)
// cond:
// result: (Or64 x y)
}
return false
}
-func rewriteValuegeneric_OpOr8(v *Value) bool {
- b := v.Block
- _ = b
+func rewriteValuegeneric_OpOr8_0(v *Value) bool {
// match: (Or8 (Const8 [c]) (Const8 [d]))
// cond:
// result: (Const8 [int64(int8(c|d))])
v.AddArg(y)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpOr8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Or8 (Or8 y x) x)
// cond:
// result: (Or8 x y)
}
return false
}
-func rewriteValuegeneric_OpPhi(v *Value) bool {
+func rewriteValuegeneric_OpPhi_0(v *Value) bool {
// match: (Phi (Const8 [c]) (Const8 [c]))
// cond:
// result: (Const8 [c])
}
return false
}
-func rewriteValuegeneric_OpPtrIndex(v *Value) bool {
+func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpRound32F(v *Value) bool {
+func rewriteValuegeneric_OpRound32F_0(v *Value) bool {
// match: (Round32F x:(Const32F))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpRound64F(v *Value) bool {
+func rewriteValuegeneric_OpRound64F_0(v *Value) bool {
// match: (Round64F x:(Const64F))
// cond:
// result: x
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16Ux8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh16x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh16x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh16x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh16x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh16x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32Ux8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh32x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh32x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh32x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64Ux8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh64x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh64x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh64x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool {
b := v.Block
_ = b
types := &b.Func.Config.Types
}
return false
}
-func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool {
+func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8Ux8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8x16(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x16 <t> x (Const16 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8x32(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x32 <t> x (Const32 [c]))
}
return false
}
-func rewriteValuegeneric_OpRsh8x64(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x64 (Const8 [c]) (Const64 [d]))
}
return false
}
-func rewriteValuegeneric_OpRsh8x8(v *Value) bool {
+func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Rsh8x8 <t> x (Const8 [c]))
}
return false
}
-func rewriteValuegeneric_OpSignExt16to32(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool {
// match: (SignExt16to32 (Const16 [c]))
// cond:
// result: (Const32 [int64( int16(c))])
}
return false
}
-func rewriteValuegeneric_OpSignExt16to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool {
// match: (SignExt16to64 (Const16 [c]))
// cond:
// result: (Const64 [int64( int16(c))])
}
return false
}
-func rewriteValuegeneric_OpSignExt32to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool {
// match: (SignExt32to64 (Const32 [c]))
// cond:
// result: (Const64 [int64( int32(c))])
}
return false
}
-func rewriteValuegeneric_OpSignExt8to16(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool {
// match: (SignExt8to16 (Const8 [c]))
// cond:
// result: (Const16 [int64( int8(c))])
}
return false
}
-func rewriteValuegeneric_OpSignExt8to32(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool {
// match: (SignExt8to32 (Const8 [c]))
// cond:
// result: (Const32 [int64( int8(c))])
}
return false
}
-func rewriteValuegeneric_OpSignExt8to64(v *Value) bool {
+func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool {
// match: (SignExt8to64 (Const8 [c]))
// cond:
// result: (Const64 [int64( int8(c))])
}
return false
}
-func rewriteValuegeneric_OpSliceCap(v *Value) bool {
+func rewriteValuegeneric_OpSliceCap_0(v *Value) bool {
// match: (SliceCap (SliceMake _ _ (Const64 <t> [c])))
// cond:
// result: (Const64 <t> [c])
}
return false
}
-func rewriteValuegeneric_OpSliceLen(v *Value) bool {
+func rewriteValuegeneric_OpSliceLen_0(v *Value) bool {
// match: (SliceLen (SliceMake _ (Const64 <t> [c]) _))
// cond:
// result: (Const64 <t> [c])
}
return false
}
-func rewriteValuegeneric_OpSlicePtr(v *Value) bool {
+func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool {
// match: (SlicePtr (SliceMake (SlicePtr x) _ _))
// cond:
// result: (SlicePtr x)
}
return false
}
-func rewriteValuegeneric_OpSlicemask(v *Value) bool {
+func rewriteValuegeneric_OpSlicemask_0(v *Value) bool {
// match: (Slicemask (Const32 [x]))
// cond: x > 0
// result: (Const32 [-1])
}
return false
}
-func rewriteValuegeneric_OpSqrt(v *Value) bool {
+func rewriteValuegeneric_OpSqrt_0(v *Value) bool {
// match: (Sqrt (Const64F [c]))
// cond:
// result: (Const64F [f2i(math.Sqrt(i2f(c)))])
}
return false
}
-func rewriteValuegeneric_OpStore(v *Value) bool {
+func rewriteValuegeneric_OpStore_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
v.AddArg(mem)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpStore_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ config := b.Func.Config
+ _ = config
// match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem)
// cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize
// result: mem
}
return false
}
-func rewriteValuegeneric_OpStringLen(v *Value) bool {
+func rewriteValuegeneric_OpStringLen_0(v *Value) bool {
// match: (StringLen (StringMake _ (Const64 <t> [c])))
// cond:
// result: (Const64 <t> [c])
}
return false
}
-func rewriteValuegeneric_OpStringPtr(v *Value) bool {
+func rewriteValuegeneric_OpStringPtr_0(v *Value) bool {
// match: (StringPtr (StringMake (Const64 <t> [c]) _))
// cond:
// result: (Const64 <t> [c])
}
return false
}
-func rewriteValuegeneric_OpStructSelect(v *Value) bool {
- b := v.Block
- _ = b
- fe := b.Func.fe
- _ = fe
+func rewriteValuegeneric_OpStructSelect_0(v *Value) bool {
// match: (StructSelect (StructMake1 x))
// cond:
// result: x
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpStructSelect_10(v *Value) bool {
+ b := v.Block
+ _ = b
+ fe := b.Func.fe
+ _ = fe
// match: (StructSelect [i] x:(Load <t> ptr mem))
// cond: !fe.CanSSA(t)
// result: @x.Block (Load <v.Type> (OffPtr <v.Type.PtrTo()> [t.FieldOff(int(i))] ptr) mem)
}
return false
}
-func rewriteValuegeneric_OpSub16(v *Value) bool {
+func rewriteValuegeneric_OpSub16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub16 (Const16 [c]) (Const16 [d]))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpSub16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Sub16 (Const16 <t> [c]) (Sub16 (Const16 <t> [d]) x))
// cond:
// result: (Add16 (Const16 <t> [int64(int16(c-d))]) x)
}
return false
}
-func rewriteValuegeneric_OpSub32(v *Value) bool {
+func rewriteValuegeneric_OpSub32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub32 (Const32 [c]) (Const32 [d]))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpSub32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Sub32 (Const32 <t> [c]) (Sub32 (Const32 <t> [d]) x))
// cond:
// result: (Add32 (Const32 <t> [int64(int32(c-d))]) x)
}
return false
}
-func rewriteValuegeneric_OpSub32F(v *Value) bool {
+func rewriteValuegeneric_OpSub32F_0(v *Value) bool {
// match: (Sub32F (Const32F [c]) (Const32F [d]))
// cond:
// result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))])
}
return false
}
-func rewriteValuegeneric_OpSub64(v *Value) bool {
+func rewriteValuegeneric_OpSub64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub64 (Const64 [c]) (Const64 [d]))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpSub64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Sub64 (Const64 <t> [c]) (Sub64 (Const64 <t> [d]) x))
// cond:
// result: (Add64 (Const64 <t> [c-d]) x)
}
return false
}
-func rewriteValuegeneric_OpSub64F(v *Value) bool {
+func rewriteValuegeneric_OpSub64F_0(v *Value) bool {
// match: (Sub64F (Const64F [c]) (Const64F [d]))
// cond:
// result: (Const64F [f2i(i2f(c) - i2f(d))])
}
return false
}
-func rewriteValuegeneric_OpSub8(v *Value) bool {
+func rewriteValuegeneric_OpSub8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Sub8 (Const8 [c]) (Const8 [d]))
v.AddArg(x)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpSub8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Sub8 (Const8 <t> [c]) (Sub8 (Const8 <t> [d]) x))
// cond:
// result: (Add8 (Const8 <t> [int64(int8(c-d))]) x)
}
return false
}
-func rewriteValuegeneric_OpTrunc16to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool {
// match: (Trunc16to8 (Const16 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
}
return false
}
-func rewriteValuegeneric_OpTrunc32to16(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool {
// match: (Trunc32to16 (Const32 [c]))
// cond:
// result: (Const16 [int64(int16(c))])
}
return false
}
-func rewriteValuegeneric_OpTrunc32to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool {
// match: (Trunc32to8 (Const32 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
}
return false
}
-func rewriteValuegeneric_OpTrunc64to16(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool {
// match: (Trunc64to16 (Const64 [c]))
// cond:
// result: (Const16 [int64(int16(c))])
}
return false
}
-func rewriteValuegeneric_OpTrunc64to32(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool {
// match: (Trunc64to32 (Const64 [c]))
// cond:
// result: (Const32 [int64(int32(c))])
}
return false
}
-func rewriteValuegeneric_OpTrunc64to8(v *Value) bool {
+func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool {
// match: (Trunc64to8 (Const64 [c]))
// cond:
// result: (Const8 [int64(int8(c))])
}
return false
}
-func rewriteValuegeneric_OpXor16(v *Value) bool {
+func rewriteValuegeneric_OpXor16_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor16 (Const16 [c]) (Const16 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpXor16_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Xor16 (Xor16 z i:(Const16 <t>)) x)
// cond: (z.Op != OpConst16 && x.Op != OpConst16)
// result: (Xor16 i (Xor16 <t> z x))
}
return false
}
-func rewriteValuegeneric_OpXor32(v *Value) bool {
+func rewriteValuegeneric_OpXor32_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor32 (Const32 [c]) (Const32 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpXor32_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Xor32 (Xor32 z i:(Const32 <t>)) x)
// cond: (z.Op != OpConst32 && x.Op != OpConst32)
// result: (Xor32 i (Xor32 <t> z x))
}
return false
}
-func rewriteValuegeneric_OpXor64(v *Value) bool {
+func rewriteValuegeneric_OpXor64_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor64 (Const64 [c]) (Const64 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpXor64_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Xor64 (Xor64 z i:(Const64 <t>)) x)
// cond: (z.Op != OpConst64 && x.Op != OpConst64)
// result: (Xor64 i (Xor64 <t> z x))
}
return false
}
-func rewriteValuegeneric_OpXor8(v *Value) bool {
+func rewriteValuegeneric_OpXor8_0(v *Value) bool {
b := v.Block
_ = b
// match: (Xor8 (Const8 [c]) (Const8 [d]))
v.AddArg(v0)
return true
}
+ return false
+}
+func rewriteValuegeneric_OpXor8_10(v *Value) bool {
+ b := v.Block
+ _ = b
// match: (Xor8 (Xor8 z i:(Const8 <t>)) x)
// cond: (z.Op != OpConst8 && x.Op != OpConst8)
// result: (Xor8 i (Xor8 <t> z x))
}
return false
}
-func rewriteValuegeneric_OpZero(v *Value) bool {
+func rewriteValuegeneric_OpZero_0(v *Value) bool {
b := v.Block
_ = b
config := b.Func.Config
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool {
// match: (ZeroExt16to32 (Const16 [c]))
// cond:
// result: (Const32 [int64(uint16(c))])
}
return false
}
-func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool {
// match: (ZeroExt16to64 (Const16 [c]))
// cond:
// result: (Const64 [int64(uint16(c))])
}
return false
}
-func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool {
// match: (ZeroExt32to64 (Const32 [c]))
// cond:
// result: (Const64 [int64(uint32(c))])
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool {
// match: (ZeroExt8to16 (Const8 [c]))
// cond:
// result: (Const16 [int64( uint8(c))])
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool {
// match: (ZeroExt8to32 (Const8 [c]))
// cond:
// result: (Const32 [int64( uint8(c))])
}
return false
}
-func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool {
+func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool {
// match: (ZeroExt8to64 (Const8 [c]))
// cond:
// result: (Const64 [int64( uint8(c))])