diff --git a/src/cmd/compile/internal/ssa/gen/rulegen.go b/src/cmd/compile/internal/ssa/gen/rulegen.go index 94898e3648..2a07d5bdfa 100644 --- a/src/cmd/compile/internal/ssa/gen/rulegen.go +++ b/src/cmd/compile/internal/ssa/gen/rulegen.go @@ -162,12 +162,20 @@ func genRules(arch arch) { fmt.Fprintln(w, "var _ = objabi.GOROOT // in case not otherwise used") fmt.Fprintln(w) + const chunkSize = 10 // Main rewrite routine is a switch on v.Op. fmt.Fprintf(w, "func rewriteValue%s(v *Value) bool {\n", arch.name) fmt.Fprintf(w, "switch v.Op {\n") for _, op := range ops { fmt.Fprintf(w, "case %s:\n", op) - fmt.Fprintf(w, "return rewriteValue%s_%s(v)\n", arch.name, op) + fmt.Fprint(w, "return ") + for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize { + if chunk > 0 { + fmt.Fprint(w, " || ") + } + fmt.Fprintf(w, "rewriteValue%s_%s_%d(v)", arch.name, op, chunk) + } + fmt.Fprintln(w) } fmt.Fprintf(w, "}\n") fmt.Fprintf(w, "return false\n") @@ -176,67 +184,73 @@ func genRules(arch arch) { // Generate a routine per op. Note that we don't make one giant routine // because it is too big for some compilers. for _, op := range ops { - buf := new(bytes.Buffer) - var canFail bool - for i, rule := range oprules[op] { - match, cond, result := rule.parse() - fmt.Fprintf(buf, "// match: %s\n", match) - fmt.Fprintf(buf, "// cond: %s\n", cond) - fmt.Fprintf(buf, "// result: %s\n", result) + for chunk := 0; chunk < len(oprules[op]); chunk += chunkSize { + buf := new(bytes.Buffer) + var canFail bool + endchunk := chunk + chunkSize + if endchunk > len(oprules[op]) { + endchunk = len(oprules[op]) + } + for i, rule := range oprules[op][chunk:endchunk] { + match, cond, result := rule.parse() + fmt.Fprintf(buf, "// match: %s\n", match) + fmt.Fprintf(buf, "// cond: %s\n", cond) + fmt.Fprintf(buf, "// result: %s\n", result) - canFail = false - fmt.Fprintf(buf, "for {\n") - if genMatch(buf, arch, match, rule.loc) { - canFail = true + canFail = false + fmt.Fprintf(buf, "for {\n") + if genMatch(buf, arch, match, rule.loc) { + canFail = true + } + + if cond != "" { + fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond) + canFail = true + } + if !canFail && i+chunk != len(oprules[op])-1 { + log.Fatalf("unconditional rule %s is followed by other rules", match) + } + + genResult(buf, arch, result, rule.loc) + if *genLog { + fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc) + } + fmt.Fprintf(buf, "return true\n") + + fmt.Fprintf(buf, "}\n") + } + if canFail { + fmt.Fprintf(buf, "return false\n") } - if cond != "" { - fmt.Fprintf(buf, "if !(%s) {\nbreak\n}\n", cond) - canFail = true + body := buf.String() + // Do a rough match to predict whether we need b, config, fe, and/or types. + // It's not precise--thus the blank assignments--but it's good enough + // to avoid generating needless code and doing pointless nil checks. + hasb := strings.Contains(body, "b.") + hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)") + hasfe := strings.Contains(body, "fe.") + hasts := strings.Contains(body, "types.") + fmt.Fprintf(w, "func rewriteValue%s_%s_%d(v *Value) bool {\n", arch.name, op, chunk) + if hasb || hasconfig || hasfe { + fmt.Fprintln(w, "b := v.Block") + fmt.Fprintln(w, "_ = b") } - if !canFail && i != len(oprules[op])-1 { - log.Fatalf("unconditional rule %s is followed by other rules", match) + if hasconfig { + fmt.Fprintln(w, "config := b.Func.Config") + fmt.Fprintln(w, "_ = config") } - - genResult(buf, arch, result, rule.loc) - if *genLog { - fmt.Fprintf(buf, "logRule(\"%s\")\n", rule.loc) + if hasfe { + fmt.Fprintln(w, "fe := b.Func.fe") + fmt.Fprintln(w, "_ = fe") } - fmt.Fprintf(buf, "return true\n") - - fmt.Fprintf(buf, "}\n") + if hasts { + fmt.Fprintln(w, "types := &b.Func.Config.Types") + fmt.Fprintln(w, "_ = types") + } + fmt.Fprint(w, body) + fmt.Fprintf(w, "}\n") } - if canFail { - fmt.Fprintf(buf, "return false\n") - } - - body := buf.String() - // Do a rough match to predict whether we need b, config, fe, and/or types. - // It's not precise--thus the blank assignments--but it's good enough - // to avoid generating needless code and doing pointless nil checks. - hasb := strings.Contains(body, "b.") - hasconfig := strings.Contains(body, "config.") || strings.Contains(body, "config)") - hasfe := strings.Contains(body, "fe.") - hasts := strings.Contains(body, "types.") - fmt.Fprintf(w, "func rewriteValue%s_%s(v *Value) bool {\n", arch.name, op) - if hasb || hasconfig || hasfe { - fmt.Fprintln(w, "b := v.Block") - fmt.Fprintln(w, "_ = b") - } - if hasconfig { - fmt.Fprintln(w, "config := b.Func.Config") - fmt.Fprintln(w, "_ = config") - } - if hasfe { - fmt.Fprintln(w, "fe := b.Func.fe") - fmt.Fprintln(w, "_ = fe") - } - if hasts { - fmt.Fprintln(w, "types := &b.Func.Config.Types") - fmt.Fprintln(w, "_ = types") - } - fmt.Fprint(w, body) - fmt.Fprintf(w, "}\n") } // Generate block rewrite function. There are only a few block types diff --git a/src/cmd/compile/internal/ssa/rewrite386.go b/src/cmd/compile/internal/ssa/rewrite386.go index 58ef586360..d6509ae368 100644 --- a/src/cmd/compile/internal/ssa/rewrite386.go +++ b/src/cmd/compile/internal/ssa/rewrite386.go @@ -14,583 +14,583 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValue386(v *Value) bool { switch v.Op { case Op386ADCL: - return rewriteValue386_Op386ADCL(v) + return rewriteValue386_Op386ADCL_0(v) case Op386ADDL: - return rewriteValue386_Op386ADDL(v) + return rewriteValue386_Op386ADDL_0(v) || rewriteValue386_Op386ADDL_10(v) || rewriteValue386_Op386ADDL_20(v) case Op386ADDLcarry: - return rewriteValue386_Op386ADDLcarry(v) + return rewriteValue386_Op386ADDLcarry_0(v) case Op386ADDLconst: - return rewriteValue386_Op386ADDLconst(v) + return rewriteValue386_Op386ADDLconst_0(v) case Op386ANDL: - return rewriteValue386_Op386ANDL(v) + return rewriteValue386_Op386ANDL_0(v) case Op386ANDLconst: - return rewriteValue386_Op386ANDLconst(v) + return rewriteValue386_Op386ANDLconst_0(v) case Op386CMPB: - return rewriteValue386_Op386CMPB(v) + return rewriteValue386_Op386CMPB_0(v) case Op386CMPBconst: - return rewriteValue386_Op386CMPBconst(v) + return rewriteValue386_Op386CMPBconst_0(v) case Op386CMPL: - return rewriteValue386_Op386CMPL(v) + return rewriteValue386_Op386CMPL_0(v) case Op386CMPLconst: - return rewriteValue386_Op386CMPLconst(v) + return rewriteValue386_Op386CMPLconst_0(v) case Op386CMPW: - return rewriteValue386_Op386CMPW(v) + return rewriteValue386_Op386CMPW_0(v) case Op386CMPWconst: - return rewriteValue386_Op386CMPWconst(v) + return rewriteValue386_Op386CMPWconst_0(v) case Op386LEAL: - return rewriteValue386_Op386LEAL(v) + return rewriteValue386_Op386LEAL_0(v) case Op386LEAL1: - return rewriteValue386_Op386LEAL1(v) + return rewriteValue386_Op386LEAL1_0(v) case Op386LEAL2: - return rewriteValue386_Op386LEAL2(v) + return rewriteValue386_Op386LEAL2_0(v) case Op386LEAL4: - return rewriteValue386_Op386LEAL4(v) + return rewriteValue386_Op386LEAL4_0(v) case Op386LEAL8: - return rewriteValue386_Op386LEAL8(v) + return rewriteValue386_Op386LEAL8_0(v) case Op386MOVBLSX: - return rewriteValue386_Op386MOVBLSX(v) + return rewriteValue386_Op386MOVBLSX_0(v) case Op386MOVBLSXload: - return rewriteValue386_Op386MOVBLSXload(v) + return rewriteValue386_Op386MOVBLSXload_0(v) case Op386MOVBLZX: - return rewriteValue386_Op386MOVBLZX(v) + return rewriteValue386_Op386MOVBLZX_0(v) case Op386MOVBload: - return rewriteValue386_Op386MOVBload(v) + return rewriteValue386_Op386MOVBload_0(v) case Op386MOVBloadidx1: - return rewriteValue386_Op386MOVBloadidx1(v) + return rewriteValue386_Op386MOVBloadidx1_0(v) case Op386MOVBstore: - return rewriteValue386_Op386MOVBstore(v) + return rewriteValue386_Op386MOVBstore_0(v) case Op386MOVBstoreconst: - return rewriteValue386_Op386MOVBstoreconst(v) + return rewriteValue386_Op386MOVBstoreconst_0(v) case Op386MOVBstoreconstidx1: - return rewriteValue386_Op386MOVBstoreconstidx1(v) + return rewriteValue386_Op386MOVBstoreconstidx1_0(v) case Op386MOVBstoreidx1: - return rewriteValue386_Op386MOVBstoreidx1(v) + return rewriteValue386_Op386MOVBstoreidx1_0(v) || rewriteValue386_Op386MOVBstoreidx1_10(v) case Op386MOVLload: - return rewriteValue386_Op386MOVLload(v) + return rewriteValue386_Op386MOVLload_0(v) case Op386MOVLloadidx1: - return rewriteValue386_Op386MOVLloadidx1(v) + return rewriteValue386_Op386MOVLloadidx1_0(v) case Op386MOVLloadidx4: - return rewriteValue386_Op386MOVLloadidx4(v) + return rewriteValue386_Op386MOVLloadidx4_0(v) case Op386MOVLstore: - return rewriteValue386_Op386MOVLstore(v) + return rewriteValue386_Op386MOVLstore_0(v) case Op386MOVLstoreconst: - return rewriteValue386_Op386MOVLstoreconst(v) + return rewriteValue386_Op386MOVLstoreconst_0(v) case Op386MOVLstoreconstidx1: - return rewriteValue386_Op386MOVLstoreconstidx1(v) + return rewriteValue386_Op386MOVLstoreconstidx1_0(v) case Op386MOVLstoreconstidx4: - return rewriteValue386_Op386MOVLstoreconstidx4(v) + return rewriteValue386_Op386MOVLstoreconstidx4_0(v) case Op386MOVLstoreidx1: - return rewriteValue386_Op386MOVLstoreidx1(v) + return rewriteValue386_Op386MOVLstoreidx1_0(v) case Op386MOVLstoreidx4: - return rewriteValue386_Op386MOVLstoreidx4(v) + return rewriteValue386_Op386MOVLstoreidx4_0(v) case Op386MOVSDconst: - return rewriteValue386_Op386MOVSDconst(v) + return rewriteValue386_Op386MOVSDconst_0(v) case Op386MOVSDload: - return rewriteValue386_Op386MOVSDload(v) + return rewriteValue386_Op386MOVSDload_0(v) case Op386MOVSDloadidx1: - return rewriteValue386_Op386MOVSDloadidx1(v) + return rewriteValue386_Op386MOVSDloadidx1_0(v) case Op386MOVSDloadidx8: - return rewriteValue386_Op386MOVSDloadidx8(v) + return rewriteValue386_Op386MOVSDloadidx8_0(v) case Op386MOVSDstore: - return rewriteValue386_Op386MOVSDstore(v) + return rewriteValue386_Op386MOVSDstore_0(v) case Op386MOVSDstoreidx1: - return rewriteValue386_Op386MOVSDstoreidx1(v) + return rewriteValue386_Op386MOVSDstoreidx1_0(v) case Op386MOVSDstoreidx8: - return rewriteValue386_Op386MOVSDstoreidx8(v) + return rewriteValue386_Op386MOVSDstoreidx8_0(v) case Op386MOVSSconst: - return rewriteValue386_Op386MOVSSconst(v) + return rewriteValue386_Op386MOVSSconst_0(v) case Op386MOVSSload: - return rewriteValue386_Op386MOVSSload(v) + return rewriteValue386_Op386MOVSSload_0(v) case Op386MOVSSloadidx1: - return rewriteValue386_Op386MOVSSloadidx1(v) + return rewriteValue386_Op386MOVSSloadidx1_0(v) case Op386MOVSSloadidx4: - return rewriteValue386_Op386MOVSSloadidx4(v) + return rewriteValue386_Op386MOVSSloadidx4_0(v) case Op386MOVSSstore: - return rewriteValue386_Op386MOVSSstore(v) + return rewriteValue386_Op386MOVSSstore_0(v) case Op386MOVSSstoreidx1: - return rewriteValue386_Op386MOVSSstoreidx1(v) + return rewriteValue386_Op386MOVSSstoreidx1_0(v) case Op386MOVSSstoreidx4: - return rewriteValue386_Op386MOVSSstoreidx4(v) + return rewriteValue386_Op386MOVSSstoreidx4_0(v) case Op386MOVWLSX: - return rewriteValue386_Op386MOVWLSX(v) + return rewriteValue386_Op386MOVWLSX_0(v) case Op386MOVWLSXload: - return rewriteValue386_Op386MOVWLSXload(v) + return rewriteValue386_Op386MOVWLSXload_0(v) case Op386MOVWLZX: - return rewriteValue386_Op386MOVWLZX(v) + return rewriteValue386_Op386MOVWLZX_0(v) case Op386MOVWload: - return rewriteValue386_Op386MOVWload(v) + return rewriteValue386_Op386MOVWload_0(v) case Op386MOVWloadidx1: - return rewriteValue386_Op386MOVWloadidx1(v) + return rewriteValue386_Op386MOVWloadidx1_0(v) case Op386MOVWloadidx2: - return rewriteValue386_Op386MOVWloadidx2(v) + return rewriteValue386_Op386MOVWloadidx2_0(v) case Op386MOVWstore: - return rewriteValue386_Op386MOVWstore(v) + return rewriteValue386_Op386MOVWstore_0(v) case Op386MOVWstoreconst: - return rewriteValue386_Op386MOVWstoreconst(v) + return rewriteValue386_Op386MOVWstoreconst_0(v) case Op386MOVWstoreconstidx1: - return rewriteValue386_Op386MOVWstoreconstidx1(v) + return rewriteValue386_Op386MOVWstoreconstidx1_0(v) case Op386MOVWstoreconstidx2: - return rewriteValue386_Op386MOVWstoreconstidx2(v) + return rewriteValue386_Op386MOVWstoreconstidx2_0(v) case Op386MOVWstoreidx1: - return rewriteValue386_Op386MOVWstoreidx1(v) + return rewriteValue386_Op386MOVWstoreidx1_0(v) || rewriteValue386_Op386MOVWstoreidx1_10(v) case Op386MOVWstoreidx2: - return rewriteValue386_Op386MOVWstoreidx2(v) + return rewriteValue386_Op386MOVWstoreidx2_0(v) case Op386MULL: - return rewriteValue386_Op386MULL(v) + return rewriteValue386_Op386MULL_0(v) case Op386MULLconst: - return rewriteValue386_Op386MULLconst(v) + return rewriteValue386_Op386MULLconst_0(v) || rewriteValue386_Op386MULLconst_10(v) || rewriteValue386_Op386MULLconst_20(v) case Op386NEGL: - return rewriteValue386_Op386NEGL(v) + return rewriteValue386_Op386NEGL_0(v) case Op386NOTL: - return rewriteValue386_Op386NOTL(v) + return rewriteValue386_Op386NOTL_0(v) case Op386ORL: - return rewriteValue386_Op386ORL(v) + return rewriteValue386_Op386ORL_0(v) || rewriteValue386_Op386ORL_10(v) || rewriteValue386_Op386ORL_20(v) || rewriteValue386_Op386ORL_30(v) || rewriteValue386_Op386ORL_40(v) || rewriteValue386_Op386ORL_50(v) case Op386ORLconst: - return rewriteValue386_Op386ORLconst(v) + return rewriteValue386_Op386ORLconst_0(v) case Op386ROLBconst: - return rewriteValue386_Op386ROLBconst(v) + return rewriteValue386_Op386ROLBconst_0(v) case Op386ROLLconst: - return rewriteValue386_Op386ROLLconst(v) + return rewriteValue386_Op386ROLLconst_0(v) case Op386ROLWconst: - return rewriteValue386_Op386ROLWconst(v) + return rewriteValue386_Op386ROLWconst_0(v) case Op386SARB: - return rewriteValue386_Op386SARB(v) + return rewriteValue386_Op386SARB_0(v) case Op386SARBconst: - return rewriteValue386_Op386SARBconst(v) + return rewriteValue386_Op386SARBconst_0(v) case Op386SARL: - return rewriteValue386_Op386SARL(v) + return rewriteValue386_Op386SARL_0(v) case Op386SARLconst: - return rewriteValue386_Op386SARLconst(v) + return rewriteValue386_Op386SARLconst_0(v) case Op386SARW: - return rewriteValue386_Op386SARW(v) + return rewriteValue386_Op386SARW_0(v) case Op386SARWconst: - return rewriteValue386_Op386SARWconst(v) + return rewriteValue386_Op386SARWconst_0(v) case Op386SBBL: - return rewriteValue386_Op386SBBL(v) + return rewriteValue386_Op386SBBL_0(v) case Op386SBBLcarrymask: - return rewriteValue386_Op386SBBLcarrymask(v) + return rewriteValue386_Op386SBBLcarrymask_0(v) case Op386SETA: - return rewriteValue386_Op386SETA(v) + return rewriteValue386_Op386SETA_0(v) case Op386SETAE: - return rewriteValue386_Op386SETAE(v) + return rewriteValue386_Op386SETAE_0(v) case Op386SETB: - return rewriteValue386_Op386SETB(v) + return rewriteValue386_Op386SETB_0(v) case Op386SETBE: - return rewriteValue386_Op386SETBE(v) + return rewriteValue386_Op386SETBE_0(v) case Op386SETEQ: - return rewriteValue386_Op386SETEQ(v) + return rewriteValue386_Op386SETEQ_0(v) case Op386SETG: - return rewriteValue386_Op386SETG(v) + return rewriteValue386_Op386SETG_0(v) case Op386SETGE: - return rewriteValue386_Op386SETGE(v) + return rewriteValue386_Op386SETGE_0(v) case Op386SETL: - return rewriteValue386_Op386SETL(v) + return rewriteValue386_Op386SETL_0(v) case Op386SETLE: - return rewriteValue386_Op386SETLE(v) + return rewriteValue386_Op386SETLE_0(v) case Op386SETNE: - return rewriteValue386_Op386SETNE(v) + return rewriteValue386_Op386SETNE_0(v) case Op386SHLL: - return rewriteValue386_Op386SHLL(v) + return rewriteValue386_Op386SHLL_0(v) case Op386SHLLconst: - return rewriteValue386_Op386SHLLconst(v) + return rewriteValue386_Op386SHLLconst_0(v) case Op386SHRB: - return rewriteValue386_Op386SHRB(v) + return rewriteValue386_Op386SHRB_0(v) case Op386SHRBconst: - return rewriteValue386_Op386SHRBconst(v) + return rewriteValue386_Op386SHRBconst_0(v) case Op386SHRL: - return rewriteValue386_Op386SHRL(v) + return rewriteValue386_Op386SHRL_0(v) case Op386SHRLconst: - return rewriteValue386_Op386SHRLconst(v) + return rewriteValue386_Op386SHRLconst_0(v) case Op386SHRW: - return rewriteValue386_Op386SHRW(v) + return rewriteValue386_Op386SHRW_0(v) case Op386SHRWconst: - return rewriteValue386_Op386SHRWconst(v) + return rewriteValue386_Op386SHRWconst_0(v) case Op386SUBL: - return rewriteValue386_Op386SUBL(v) + return rewriteValue386_Op386SUBL_0(v) case Op386SUBLcarry: - return rewriteValue386_Op386SUBLcarry(v) + return rewriteValue386_Op386SUBLcarry_0(v) case Op386SUBLconst: - return rewriteValue386_Op386SUBLconst(v) + return rewriteValue386_Op386SUBLconst_0(v) case Op386XORL: - return rewriteValue386_Op386XORL(v) + return rewriteValue386_Op386XORL_0(v) case Op386XORLconst: - return rewriteValue386_Op386XORLconst(v) + return rewriteValue386_Op386XORLconst_0(v) case OpAdd16: - return rewriteValue386_OpAdd16(v) + return rewriteValue386_OpAdd16_0(v) case OpAdd32: - return rewriteValue386_OpAdd32(v) + return rewriteValue386_OpAdd32_0(v) case OpAdd32F: - return rewriteValue386_OpAdd32F(v) + return rewriteValue386_OpAdd32F_0(v) case OpAdd32carry: - return rewriteValue386_OpAdd32carry(v) + return rewriteValue386_OpAdd32carry_0(v) case OpAdd32withcarry: - return rewriteValue386_OpAdd32withcarry(v) + return rewriteValue386_OpAdd32withcarry_0(v) case OpAdd64F: - return rewriteValue386_OpAdd64F(v) + return rewriteValue386_OpAdd64F_0(v) case OpAdd8: - return rewriteValue386_OpAdd8(v) + return rewriteValue386_OpAdd8_0(v) case OpAddPtr: - return rewriteValue386_OpAddPtr(v) + return rewriteValue386_OpAddPtr_0(v) case OpAddr: - return rewriteValue386_OpAddr(v) + return rewriteValue386_OpAddr_0(v) case OpAnd16: - return rewriteValue386_OpAnd16(v) + return rewriteValue386_OpAnd16_0(v) case OpAnd32: - return rewriteValue386_OpAnd32(v) + return rewriteValue386_OpAnd32_0(v) case OpAnd8: - return rewriteValue386_OpAnd8(v) + return rewriteValue386_OpAnd8_0(v) case OpAndB: - return rewriteValue386_OpAndB(v) + return rewriteValue386_OpAndB_0(v) case OpAvg32u: - return rewriteValue386_OpAvg32u(v) + return rewriteValue386_OpAvg32u_0(v) case OpBswap32: - return rewriteValue386_OpBswap32(v) + return rewriteValue386_OpBswap32_0(v) case OpClosureCall: - return rewriteValue386_OpClosureCall(v) + return rewriteValue386_OpClosureCall_0(v) case OpCom16: - return rewriteValue386_OpCom16(v) + return rewriteValue386_OpCom16_0(v) case OpCom32: - return rewriteValue386_OpCom32(v) + return rewriteValue386_OpCom32_0(v) case OpCom8: - return rewriteValue386_OpCom8(v) + return rewriteValue386_OpCom8_0(v) case OpConst16: - return rewriteValue386_OpConst16(v) + return rewriteValue386_OpConst16_0(v) case OpConst32: - return rewriteValue386_OpConst32(v) + return rewriteValue386_OpConst32_0(v) case OpConst32F: - return rewriteValue386_OpConst32F(v) + return rewriteValue386_OpConst32F_0(v) case OpConst64F: - return rewriteValue386_OpConst64F(v) + return rewriteValue386_OpConst64F_0(v) case OpConst8: - return rewriteValue386_OpConst8(v) + return rewriteValue386_OpConst8_0(v) case OpConstBool: - return rewriteValue386_OpConstBool(v) + return rewriteValue386_OpConstBool_0(v) case OpConstNil: - return rewriteValue386_OpConstNil(v) + return rewriteValue386_OpConstNil_0(v) case OpConvert: - return rewriteValue386_OpConvert(v) + return rewriteValue386_OpConvert_0(v) case OpCvt32Fto32: - return rewriteValue386_OpCvt32Fto32(v) + return rewriteValue386_OpCvt32Fto32_0(v) case OpCvt32Fto64F: - return rewriteValue386_OpCvt32Fto64F(v) + return rewriteValue386_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValue386_OpCvt32to32F(v) + return rewriteValue386_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValue386_OpCvt32to64F(v) + return rewriteValue386_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValue386_OpCvt64Fto32(v) + return rewriteValue386_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValue386_OpCvt64Fto32F(v) + return rewriteValue386_OpCvt64Fto32F_0(v) case OpDiv16: - return rewriteValue386_OpDiv16(v) + return rewriteValue386_OpDiv16_0(v) case OpDiv16u: - return rewriteValue386_OpDiv16u(v) + return rewriteValue386_OpDiv16u_0(v) case OpDiv32: - return rewriteValue386_OpDiv32(v) + return rewriteValue386_OpDiv32_0(v) case OpDiv32F: - return rewriteValue386_OpDiv32F(v) + return rewriteValue386_OpDiv32F_0(v) case OpDiv32u: - return rewriteValue386_OpDiv32u(v) + return rewriteValue386_OpDiv32u_0(v) case OpDiv64F: - return rewriteValue386_OpDiv64F(v) + return rewriteValue386_OpDiv64F_0(v) case OpDiv8: - return rewriteValue386_OpDiv8(v) + return rewriteValue386_OpDiv8_0(v) case OpDiv8u: - return rewriteValue386_OpDiv8u(v) + return rewriteValue386_OpDiv8u_0(v) case OpEq16: - return rewriteValue386_OpEq16(v) + return rewriteValue386_OpEq16_0(v) case OpEq32: - return rewriteValue386_OpEq32(v) + return rewriteValue386_OpEq32_0(v) case OpEq32F: - return rewriteValue386_OpEq32F(v) + return rewriteValue386_OpEq32F_0(v) case OpEq64F: - return rewriteValue386_OpEq64F(v) + return rewriteValue386_OpEq64F_0(v) case OpEq8: - return rewriteValue386_OpEq8(v) + return rewriteValue386_OpEq8_0(v) case OpEqB: - return rewriteValue386_OpEqB(v) + return rewriteValue386_OpEqB_0(v) case OpEqPtr: - return rewriteValue386_OpEqPtr(v) + return rewriteValue386_OpEqPtr_0(v) case OpGeq16: - return rewriteValue386_OpGeq16(v) + return rewriteValue386_OpGeq16_0(v) case OpGeq16U: - return rewriteValue386_OpGeq16U(v) + return rewriteValue386_OpGeq16U_0(v) case OpGeq32: - return rewriteValue386_OpGeq32(v) + return rewriteValue386_OpGeq32_0(v) case OpGeq32F: - return rewriteValue386_OpGeq32F(v) + return rewriteValue386_OpGeq32F_0(v) case OpGeq32U: - return rewriteValue386_OpGeq32U(v) + return rewriteValue386_OpGeq32U_0(v) case OpGeq64F: - return rewriteValue386_OpGeq64F(v) + return rewriteValue386_OpGeq64F_0(v) case OpGeq8: - return rewriteValue386_OpGeq8(v) + return rewriteValue386_OpGeq8_0(v) case OpGeq8U: - return rewriteValue386_OpGeq8U(v) + return rewriteValue386_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValue386_OpGetClosurePtr(v) + return rewriteValue386_OpGetClosurePtr_0(v) case OpGetG: - return rewriteValue386_OpGetG(v) + return rewriteValue386_OpGetG_0(v) case OpGreater16: - return rewriteValue386_OpGreater16(v) + return rewriteValue386_OpGreater16_0(v) case OpGreater16U: - return rewriteValue386_OpGreater16U(v) + return rewriteValue386_OpGreater16U_0(v) case OpGreater32: - return rewriteValue386_OpGreater32(v) + return rewriteValue386_OpGreater32_0(v) case OpGreater32F: - return rewriteValue386_OpGreater32F(v) + return rewriteValue386_OpGreater32F_0(v) case OpGreater32U: - return rewriteValue386_OpGreater32U(v) + return rewriteValue386_OpGreater32U_0(v) case OpGreater64F: - return rewriteValue386_OpGreater64F(v) + return rewriteValue386_OpGreater64F_0(v) case OpGreater8: - return rewriteValue386_OpGreater8(v) + return rewriteValue386_OpGreater8_0(v) case OpGreater8U: - return rewriteValue386_OpGreater8U(v) + return rewriteValue386_OpGreater8U_0(v) case OpHmul32: - return rewriteValue386_OpHmul32(v) + return rewriteValue386_OpHmul32_0(v) case OpHmul32u: - return rewriteValue386_OpHmul32u(v) + return rewriteValue386_OpHmul32u_0(v) case OpInterCall: - return rewriteValue386_OpInterCall(v) + return rewriteValue386_OpInterCall_0(v) case OpIsInBounds: - return rewriteValue386_OpIsInBounds(v) + return rewriteValue386_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValue386_OpIsNonNil(v) + return rewriteValue386_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValue386_OpIsSliceInBounds(v) + return rewriteValue386_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValue386_OpLeq16(v) + return rewriteValue386_OpLeq16_0(v) case OpLeq16U: - return rewriteValue386_OpLeq16U(v) + return rewriteValue386_OpLeq16U_0(v) case OpLeq32: - return rewriteValue386_OpLeq32(v) + return rewriteValue386_OpLeq32_0(v) case OpLeq32F: - return rewriteValue386_OpLeq32F(v) + return rewriteValue386_OpLeq32F_0(v) case OpLeq32U: - return rewriteValue386_OpLeq32U(v) + return rewriteValue386_OpLeq32U_0(v) case OpLeq64F: - return rewriteValue386_OpLeq64F(v) + return rewriteValue386_OpLeq64F_0(v) case OpLeq8: - return rewriteValue386_OpLeq8(v) + return rewriteValue386_OpLeq8_0(v) case OpLeq8U: - return rewriteValue386_OpLeq8U(v) + return rewriteValue386_OpLeq8U_0(v) case OpLess16: - return rewriteValue386_OpLess16(v) + return rewriteValue386_OpLess16_0(v) case OpLess16U: - return rewriteValue386_OpLess16U(v) + return rewriteValue386_OpLess16U_0(v) case OpLess32: - return rewriteValue386_OpLess32(v) + return rewriteValue386_OpLess32_0(v) case OpLess32F: - return rewriteValue386_OpLess32F(v) + return rewriteValue386_OpLess32F_0(v) case OpLess32U: - return rewriteValue386_OpLess32U(v) + return rewriteValue386_OpLess32U_0(v) case OpLess64F: - return rewriteValue386_OpLess64F(v) + return rewriteValue386_OpLess64F_0(v) case OpLess8: - return rewriteValue386_OpLess8(v) + return rewriteValue386_OpLess8_0(v) case OpLess8U: - return rewriteValue386_OpLess8U(v) + return rewriteValue386_OpLess8U_0(v) case OpLoad: - return rewriteValue386_OpLoad(v) + return rewriteValue386_OpLoad_0(v) case OpLsh16x16: - return rewriteValue386_OpLsh16x16(v) + return rewriteValue386_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValue386_OpLsh16x32(v) + return rewriteValue386_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValue386_OpLsh16x64(v) + return rewriteValue386_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValue386_OpLsh16x8(v) + return rewriteValue386_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValue386_OpLsh32x16(v) + return rewriteValue386_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValue386_OpLsh32x32(v) + return rewriteValue386_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValue386_OpLsh32x64(v) + return rewriteValue386_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValue386_OpLsh32x8(v) + return rewriteValue386_OpLsh32x8_0(v) case OpLsh8x16: - return rewriteValue386_OpLsh8x16(v) + return rewriteValue386_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValue386_OpLsh8x32(v) + return rewriteValue386_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValue386_OpLsh8x64(v) + return rewriteValue386_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValue386_OpLsh8x8(v) + return rewriteValue386_OpLsh8x8_0(v) case OpMod16: - return rewriteValue386_OpMod16(v) + return rewriteValue386_OpMod16_0(v) case OpMod16u: - return rewriteValue386_OpMod16u(v) + return rewriteValue386_OpMod16u_0(v) case OpMod32: - return rewriteValue386_OpMod32(v) + return rewriteValue386_OpMod32_0(v) case OpMod32u: - return rewriteValue386_OpMod32u(v) + return rewriteValue386_OpMod32u_0(v) case OpMod8: - return rewriteValue386_OpMod8(v) + return rewriteValue386_OpMod8_0(v) case OpMod8u: - return rewriteValue386_OpMod8u(v) + return rewriteValue386_OpMod8u_0(v) case OpMove: - return rewriteValue386_OpMove(v) + return rewriteValue386_OpMove_0(v) || rewriteValue386_OpMove_10(v) case OpMul16: - return rewriteValue386_OpMul16(v) + return rewriteValue386_OpMul16_0(v) case OpMul32: - return rewriteValue386_OpMul32(v) + return rewriteValue386_OpMul32_0(v) case OpMul32F: - return rewriteValue386_OpMul32F(v) + return rewriteValue386_OpMul32F_0(v) case OpMul32uhilo: - return rewriteValue386_OpMul32uhilo(v) + return rewriteValue386_OpMul32uhilo_0(v) case OpMul64F: - return rewriteValue386_OpMul64F(v) + return rewriteValue386_OpMul64F_0(v) case OpMul8: - return rewriteValue386_OpMul8(v) + return rewriteValue386_OpMul8_0(v) case OpNeg16: - return rewriteValue386_OpNeg16(v) + return rewriteValue386_OpNeg16_0(v) case OpNeg32: - return rewriteValue386_OpNeg32(v) + return rewriteValue386_OpNeg32_0(v) case OpNeg32F: - return rewriteValue386_OpNeg32F(v) + return rewriteValue386_OpNeg32F_0(v) case OpNeg64F: - return rewriteValue386_OpNeg64F(v) + return rewriteValue386_OpNeg64F_0(v) case OpNeg8: - return rewriteValue386_OpNeg8(v) + return rewriteValue386_OpNeg8_0(v) case OpNeq16: - return rewriteValue386_OpNeq16(v) + return rewriteValue386_OpNeq16_0(v) case OpNeq32: - return rewriteValue386_OpNeq32(v) + return rewriteValue386_OpNeq32_0(v) case OpNeq32F: - return rewriteValue386_OpNeq32F(v) + return rewriteValue386_OpNeq32F_0(v) case OpNeq64F: - return rewriteValue386_OpNeq64F(v) + return rewriteValue386_OpNeq64F_0(v) case OpNeq8: - return rewriteValue386_OpNeq8(v) + return rewriteValue386_OpNeq8_0(v) case OpNeqB: - return rewriteValue386_OpNeqB(v) + return rewriteValue386_OpNeqB_0(v) case OpNeqPtr: - return rewriteValue386_OpNeqPtr(v) + return rewriteValue386_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValue386_OpNilCheck(v) + return rewriteValue386_OpNilCheck_0(v) case OpNot: - return rewriteValue386_OpNot(v) + return rewriteValue386_OpNot_0(v) case OpOffPtr: - return rewriteValue386_OpOffPtr(v) + return rewriteValue386_OpOffPtr_0(v) case OpOr16: - return rewriteValue386_OpOr16(v) + return rewriteValue386_OpOr16_0(v) case OpOr32: - return rewriteValue386_OpOr32(v) + return rewriteValue386_OpOr32_0(v) case OpOr8: - return rewriteValue386_OpOr8(v) + return rewriteValue386_OpOr8_0(v) case OpOrB: - return rewriteValue386_OpOrB(v) + return rewriteValue386_OpOrB_0(v) case OpRound32F: - return rewriteValue386_OpRound32F(v) + return rewriteValue386_OpRound32F_0(v) case OpRound64F: - return rewriteValue386_OpRound64F(v) + return rewriteValue386_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValue386_OpRsh16Ux16(v) + return rewriteValue386_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValue386_OpRsh16Ux32(v) + return rewriteValue386_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValue386_OpRsh16Ux64(v) + return rewriteValue386_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValue386_OpRsh16Ux8(v) + return rewriteValue386_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValue386_OpRsh16x16(v) + return rewriteValue386_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValue386_OpRsh16x32(v) + return rewriteValue386_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValue386_OpRsh16x64(v) + return rewriteValue386_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValue386_OpRsh16x8(v) + return rewriteValue386_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValue386_OpRsh32Ux16(v) + return rewriteValue386_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValue386_OpRsh32Ux32(v) + return rewriteValue386_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValue386_OpRsh32Ux64(v) + return rewriteValue386_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValue386_OpRsh32Ux8(v) + return rewriteValue386_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValue386_OpRsh32x16(v) + return rewriteValue386_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValue386_OpRsh32x32(v) + return rewriteValue386_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValue386_OpRsh32x64(v) + return rewriteValue386_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValue386_OpRsh32x8(v) + return rewriteValue386_OpRsh32x8_0(v) case OpRsh8Ux16: - return rewriteValue386_OpRsh8Ux16(v) + return rewriteValue386_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValue386_OpRsh8Ux32(v) + return rewriteValue386_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValue386_OpRsh8Ux64(v) + return rewriteValue386_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValue386_OpRsh8Ux8(v) + return rewriteValue386_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValue386_OpRsh8x16(v) + return rewriteValue386_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValue386_OpRsh8x32(v) + return rewriteValue386_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValue386_OpRsh8x64(v) + return rewriteValue386_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValue386_OpRsh8x8(v) + return rewriteValue386_OpRsh8x8_0(v) case OpSignExt16to32: - return rewriteValue386_OpSignExt16to32(v) + return rewriteValue386_OpSignExt16to32_0(v) case OpSignExt8to16: - return rewriteValue386_OpSignExt8to16(v) + return rewriteValue386_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValue386_OpSignExt8to32(v) + return rewriteValue386_OpSignExt8to32_0(v) case OpSignmask: - return rewriteValue386_OpSignmask(v) + return rewriteValue386_OpSignmask_0(v) case OpSlicemask: - return rewriteValue386_OpSlicemask(v) + return rewriteValue386_OpSlicemask_0(v) case OpSqrt: - return rewriteValue386_OpSqrt(v) + return rewriteValue386_OpSqrt_0(v) case OpStaticCall: - return rewriteValue386_OpStaticCall(v) + return rewriteValue386_OpStaticCall_0(v) case OpStore: - return rewriteValue386_OpStore(v) + return rewriteValue386_OpStore_0(v) case OpSub16: - return rewriteValue386_OpSub16(v) + return rewriteValue386_OpSub16_0(v) case OpSub32: - return rewriteValue386_OpSub32(v) + return rewriteValue386_OpSub32_0(v) case OpSub32F: - return rewriteValue386_OpSub32F(v) + return rewriteValue386_OpSub32F_0(v) case OpSub32carry: - return rewriteValue386_OpSub32carry(v) + return rewriteValue386_OpSub32carry_0(v) case OpSub32withcarry: - return rewriteValue386_OpSub32withcarry(v) + return rewriteValue386_OpSub32withcarry_0(v) case OpSub64F: - return rewriteValue386_OpSub64F(v) + return rewriteValue386_OpSub64F_0(v) case OpSub8: - return rewriteValue386_OpSub8(v) + return rewriteValue386_OpSub8_0(v) case OpSubPtr: - return rewriteValue386_OpSubPtr(v) + return rewriteValue386_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValue386_OpTrunc16to8(v) + return rewriteValue386_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValue386_OpTrunc32to16(v) + return rewriteValue386_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValue386_OpTrunc32to8(v) + return rewriteValue386_OpTrunc32to8_0(v) case OpXor16: - return rewriteValue386_OpXor16(v) + return rewriteValue386_OpXor16_0(v) case OpXor32: - return rewriteValue386_OpXor32(v) + return rewriteValue386_OpXor32_0(v) case OpXor8: - return rewriteValue386_OpXor8(v) + return rewriteValue386_OpXor8_0(v) case OpZero: - return rewriteValue386_OpZero(v) + return rewriteValue386_OpZero_0(v) || rewriteValue386_OpZero_10(v) case OpZeroExt16to32: - return rewriteValue386_OpZeroExt16to32(v) + return rewriteValue386_OpZeroExt16to32_0(v) case OpZeroExt8to16: - return rewriteValue386_OpZeroExt8to16(v) + return rewriteValue386_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValue386_OpZeroExt8to32(v) + return rewriteValue386_OpZeroExt8to32_0(v) case OpZeromask: - return rewriteValue386_OpZeromask(v) + return rewriteValue386_OpZeromask_0(v) } return false } -func rewriteValue386_Op386ADCL(v *Value) bool { +func rewriteValue386_Op386ADCL_0(v *Value) bool { // match: (ADCL x (MOVLconst [c]) f) // cond: // result: (ADCLconst [c] x f) @@ -661,7 +661,7 @@ func rewriteValue386_Op386ADCL(v *Value) bool { } return false } -func rewriteValue386_Op386ADDL(v *Value) bool { +func rewriteValue386_Op386ADDL_0(v *Value) bool { // match: (ADDL x (MOVLconst [c])) // cond: // result: (ADDLconst [c] x) @@ -888,6 +888,9 @@ func rewriteValue386_Op386ADDL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValue386_Op386ADDL_10(v *Value) bool { // match: (ADDL x (SHLLconst [2] y)) // cond: // result: (LEAL4 x y) @@ -1068,6 +1071,9 @@ func rewriteValue386_Op386ADDL(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValue386_Op386ADDL_20(v *Value) bool { // match: (ADDL (ADDLconst [c] x) y) // cond: // result: (LEAL1 [c] x y) @@ -1178,7 +1184,7 @@ func rewriteValue386_Op386ADDL(v *Value) bool { } return false } -func rewriteValue386_Op386ADDLcarry(v *Value) bool { +func rewriteValue386_Op386ADDLcarry_0(v *Value) bool { // match: (ADDLcarry x (MOVLconst [c])) // cond: // result: (ADDLconstcarry [c] x) @@ -1211,7 +1217,7 @@ func rewriteValue386_Op386ADDLcarry(v *Value) bool { } return false } -func rewriteValue386_Op386ADDLconst(v *Value) bool { +func rewriteValue386_Op386ADDLconst_0(v *Value) bool { // match: (ADDLconst [c] (ADDL x y)) // cond: // result: (LEAL1 [c] x y) @@ -1388,7 +1394,7 @@ func rewriteValue386_Op386ADDLconst(v *Value) bool { } return false } -func rewriteValue386_Op386ANDL(v *Value) bool { +func rewriteValue386_Op386ANDL_0(v *Value) bool { // match: (ANDL x (MOVLconst [c])) // cond: // result: (ANDLconst [c] x) @@ -1434,7 +1440,7 @@ func rewriteValue386_Op386ANDL(v *Value) bool { } return false } -func rewriteValue386_Op386ANDLconst(v *Value) bool { +func rewriteValue386_Op386ANDLconst_0(v *Value) bool { // match: (ANDLconst [c] (ANDLconst [d] x)) // cond: // result: (ANDLconst [c & d] x) @@ -1493,7 +1499,7 @@ func rewriteValue386_Op386ANDLconst(v *Value) bool { } return false } -func rewriteValue386_Op386CMPB(v *Value) bool { +func rewriteValue386_Op386CMPB_0(v *Value) bool { b := v.Block _ = b // match: (CMPB x (MOVLconst [c])) @@ -1530,7 +1536,7 @@ func rewriteValue386_Op386CMPB(v *Value) bool { } return false } -func rewriteValue386_Op386CMPBconst(v *Value) bool { +func rewriteValue386_Op386CMPBconst_0(v *Value) bool { // match: (CMPBconst (MOVLconst [x]) [y]) // cond: int8(x)==int8(y) // result: (FlagEQ) @@ -1678,7 +1684,7 @@ func rewriteValue386_Op386CMPBconst(v *Value) bool { } return false } -func rewriteValue386_Op386CMPL(v *Value) bool { +func rewriteValue386_Op386CMPL_0(v *Value) bool { b := v.Block _ = b // match: (CMPL x (MOVLconst [c])) @@ -1715,7 +1721,7 @@ func rewriteValue386_Op386CMPL(v *Value) bool { } return false } -func rewriteValue386_Op386CMPLconst(v *Value) bool { +func rewriteValue386_Op386CMPLconst_0(v *Value) bool { // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -1879,7 +1885,7 @@ func rewriteValue386_Op386CMPLconst(v *Value) bool { } return false } -func rewriteValue386_Op386CMPW(v *Value) bool { +func rewriteValue386_Op386CMPW_0(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVLconst [c])) @@ -1916,7 +1922,7 @@ func rewriteValue386_Op386CMPW(v *Value) bool { } return false } -func rewriteValue386_Op386CMPWconst(v *Value) bool { +func rewriteValue386_Op386CMPWconst_0(v *Value) bool { // match: (CMPWconst (MOVLconst [x]) [y]) // cond: int16(x)==int16(y) // result: (FlagEQ) @@ -2064,7 +2070,7 @@ func rewriteValue386_Op386CMPWconst(v *Value) bool { } return false } -func rewriteValue386_Op386LEAL(v *Value) bool { +func rewriteValue386_Op386LEAL_0(v *Value) bool { // match: (LEAL [c] {s} (ADDLconst [d] x)) // cond: is32Bit(c+d) // result: (LEAL [c+d] {s} x) @@ -2228,7 +2234,7 @@ func rewriteValue386_Op386LEAL(v *Value) bool { } return false } -func rewriteValue386_Op386LEAL1(v *Value) bool { +func rewriteValue386_Op386LEAL1_0(v *Value) bool { // match: (LEAL1 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL1 [c+d] {s} x y) @@ -2457,7 +2463,7 @@ func rewriteValue386_Op386LEAL1(v *Value) bool { } return false } -func rewriteValue386_Op386LEAL2(v *Value) bool { +func rewriteValue386_Op386LEAL2_0(v *Value) bool { // match: (LEAL2 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL2 [c+d] {s} x y) @@ -2574,7 +2580,7 @@ func rewriteValue386_Op386LEAL2(v *Value) bool { } return false } -func rewriteValue386_Op386LEAL4(v *Value) bool { +func rewriteValue386_Op386LEAL4_0(v *Value) bool { // match: (LEAL4 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL4 [c+d] {s} x y) @@ -2669,7 +2675,7 @@ func rewriteValue386_Op386LEAL4(v *Value) bool { } return false } -func rewriteValue386_Op386LEAL8(v *Value) bool { +func rewriteValue386_Op386LEAL8_0(v *Value) bool { // match: (LEAL8 [c] {s} (ADDLconst [d] x) y) // cond: is32Bit(c+d) && x.Op != OpSB // result: (LEAL8 [c+d] {s} x y) @@ -2742,7 +2748,7 @@ func rewriteValue386_Op386LEAL8(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBLSX(v *Value) bool { +func rewriteValue386_Op386MOVBLSX_0(v *Value) bool { b := v.Block _ = b // match: (MOVBLSX x:(MOVBload [off] {sym} ptr mem)) @@ -2790,7 +2796,7 @@ func rewriteValue386_Op386MOVBLSX(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBLSXload(v *Value) bool { +func rewriteValue386_Op386MOVBLSXload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -2821,7 +2827,7 @@ func rewriteValue386_Op386MOVBLSXload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBLZX(v *Value) bool { +func rewriteValue386_Op386MOVBLZX_0(v *Value) bool { b := v.Block _ = b // match: (MOVBLZX x:(MOVBload [off] {sym} ptr mem)) @@ -2893,7 +2899,7 @@ func rewriteValue386_Op386MOVBLZX(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBload(v *Value) bool { +func rewriteValue386_Op386MOVBload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -3020,7 +3026,7 @@ func rewriteValue386_Op386MOVBload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBloadidx1(v *Value) bool { +func rewriteValue386_Op386MOVBloadidx1_0(v *Value) bool { // match: (MOVBloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVBloadidx1 [c+d] {sym} ptr idx mem) @@ -3111,7 +3117,7 @@ func rewriteValue386_Op386MOVBloadidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBstore(v *Value) bool { +func rewriteValue386_Op386MOVBstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -3379,7 +3385,7 @@ func rewriteValue386_Op386MOVBstore(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBstoreconst(v *Value) bool { +func rewriteValue386_Op386MOVBstoreconst_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -3509,7 +3515,7 @@ func rewriteValue386_Op386MOVBstoreconst(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool { +func rewriteValue386_Op386MOVBstoreconstidx1_0(v *Value) bool { // match: (MOVBstoreconstidx1 [x] {sym} (ADDLconst [c] ptr) idx mem) // cond: // result: (MOVBstoreconstidx1 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -3590,7 +3596,7 @@ func rewriteValue386_Op386MOVBstoreconstidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool { +func rewriteValue386_Op386MOVBstoreidx1_0(v *Value) bool { // match: (MOVBstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVBstoreidx1 [c+d] {sym} ptr idx val mem) @@ -3985,6 +3991,9 @@ func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValue386_Op386MOVBstoreidx1_10(v *Value) bool { // match: (MOVBstoreidx1 [i] {s} idx p (SHRLconst [j] w) x:(MOVBstoreidx1 [i-1] {s} p idx w0:(SHRLconst [j-8] w) mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWstoreidx1 [i-1] {s} p idx w0 mem) @@ -4093,7 +4102,7 @@ func rewriteValue386_Op386MOVBstoreidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLload(v *Value) bool { +func rewriteValue386_Op386MOVLload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -4246,7 +4255,7 @@ func rewriteValue386_Op386MOVLload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLloadidx1(v *Value) bool { +func rewriteValue386_Op386MOVLloadidx1_0(v *Value) bool { // match: (MOVLloadidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) // cond: // result: (MOVLloadidx4 [c] {sym} ptr idx mem) @@ -4385,7 +4394,7 @@ func rewriteValue386_Op386MOVLloadidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLloadidx4(v *Value) bool { +func rewriteValue386_Op386MOVLloadidx4_0(v *Value) bool { // match: (MOVLloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVLloadidx4 [c+d] {sym} ptr idx mem) @@ -4432,7 +4441,7 @@ func rewriteValue386_Op386MOVLloadidx4(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstore(v *Value) bool { +func rewriteValue386_Op386MOVLstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -4595,7 +4604,7 @@ func rewriteValue386_Op386MOVLstore(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstoreconst(v *Value) bool { +func rewriteValue386_Op386MOVLstoreconst_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -4722,7 +4731,7 @@ func rewriteValue386_Op386MOVLstoreconst(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool { +func rewriteValue386_Op386MOVLstoreconstidx1_0(v *Value) bool { // match: (MOVLstoreconstidx1 [c] {sym} ptr (SHLLconst [2] idx) mem) // cond: // result: (MOVLstoreconstidx4 [c] {sym} ptr idx mem) @@ -4793,7 +4802,7 @@ func rewriteValue386_Op386MOVLstoreconstidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool { +func rewriteValue386_Op386MOVLstoreconstidx4_0(v *Value) bool { // match: (MOVLstoreconstidx4 [x] {sym} (ADDLconst [c] ptr) idx mem) // cond: // result: (MOVLstoreconstidx4 [ValAndOff(x).add(c)] {sym} ptr idx mem) @@ -4840,7 +4849,7 @@ func rewriteValue386_Op386MOVLstoreconstidx4(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool { +func rewriteValue386_Op386MOVLstoreidx1_0(v *Value) bool { // match: (MOVLstoreidx1 [c] {sym} ptr (SHLLconst [2] idx) val mem) // cond: // result: (MOVLstoreidx4 [c] {sym} ptr idx val mem) @@ -4991,7 +5000,7 @@ func rewriteValue386_Op386MOVLstoreidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool { +func rewriteValue386_Op386MOVLstoreidx4_0(v *Value) bool { // match: (MOVLstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVLstoreidx4 [c+d] {sym} ptr idx val mem) @@ -5042,7 +5051,7 @@ func rewriteValue386_Op386MOVLstoreidx4(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDconst(v *Value) bool { +func rewriteValue386_Op386MOVSDconst_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5065,7 +5074,7 @@ func rewriteValue386_Op386MOVSDconst(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDload(v *Value) bool { +func rewriteValue386_Op386MOVSDload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5195,7 +5204,7 @@ func rewriteValue386_Op386MOVSDload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool { +func rewriteValue386_Op386MOVSDloadidx1_0(v *Value) bool { // match: (MOVSDloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSDloadidx1 [c+d] {sym} ptr idx mem) @@ -5242,7 +5251,7 @@ func rewriteValue386_Op386MOVSDloadidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool { +func rewriteValue386_Op386MOVSDloadidx8_0(v *Value) bool { // match: (MOVSDloadidx8 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSDloadidx8 [c+d] {sym} ptr idx mem) @@ -5289,7 +5298,7 @@ func rewriteValue386_Op386MOVSDloadidx8(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDstore(v *Value) bool { +func rewriteValue386_Op386MOVSDstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5429,7 +5438,7 @@ func rewriteValue386_Op386MOVSDstore(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool { +func rewriteValue386_Op386MOVSDstoreidx1_0(v *Value) bool { // match: (MOVSDstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSDstoreidx1 [c+d] {sym} ptr idx val mem) @@ -5480,7 +5489,7 @@ func rewriteValue386_Op386MOVSDstoreidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool { +func rewriteValue386_Op386MOVSDstoreidx8_0(v *Value) bool { // match: (MOVSDstoreidx8 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSDstoreidx8 [c+d] {sym} ptr idx val mem) @@ -5531,7 +5540,7 @@ func rewriteValue386_Op386MOVSDstoreidx8(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSconst(v *Value) bool { +func rewriteValue386_Op386MOVSSconst_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5554,7 +5563,7 @@ func rewriteValue386_Op386MOVSSconst(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSload(v *Value) bool { +func rewriteValue386_Op386MOVSSload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5684,7 +5693,7 @@ func rewriteValue386_Op386MOVSSload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool { +func rewriteValue386_Op386MOVSSloadidx1_0(v *Value) bool { // match: (MOVSSloadidx1 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSSloadidx1 [c+d] {sym} ptr idx mem) @@ -5731,7 +5740,7 @@ func rewriteValue386_Op386MOVSSloadidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool { +func rewriteValue386_Op386MOVSSloadidx4_0(v *Value) bool { // match: (MOVSSloadidx4 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVSSloadidx4 [c+d] {sym} ptr idx mem) @@ -5778,7 +5787,7 @@ func rewriteValue386_Op386MOVSSloadidx4(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSstore(v *Value) bool { +func rewriteValue386_Op386MOVSSstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5918,7 +5927,7 @@ func rewriteValue386_Op386MOVSSstore(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool { +func rewriteValue386_Op386MOVSSstoreidx1_0(v *Value) bool { // match: (MOVSSstoreidx1 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSSstoreidx1 [c+d] {sym} ptr idx val mem) @@ -5969,7 +5978,7 @@ func rewriteValue386_Op386MOVSSstoreidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool { +func rewriteValue386_Op386MOVSSstoreidx4_0(v *Value) bool { // match: (MOVSSstoreidx4 [c] {sym} (ADDLconst [d] ptr) idx val mem) // cond: // result: (MOVSSstoreidx4 [c+d] {sym} ptr idx val mem) @@ -6020,7 +6029,7 @@ func rewriteValue386_Op386MOVSSstoreidx4(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWLSX(v *Value) bool { +func rewriteValue386_Op386MOVWLSX_0(v *Value) bool { b := v.Block _ = b // match: (MOVWLSX x:(MOVWload [off] {sym} ptr mem)) @@ -6068,7 +6077,7 @@ func rewriteValue386_Op386MOVWLSX(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWLSXload(v *Value) bool { +func rewriteValue386_Op386MOVWLSXload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6099,7 +6108,7 @@ func rewriteValue386_Op386MOVWLSXload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWLZX(v *Value) bool { +func rewriteValue386_Op386MOVWLZX_0(v *Value) bool { b := v.Block _ = b // match: (MOVWLZX x:(MOVWload [off] {sym} ptr mem)) @@ -6198,7 +6207,7 @@ func rewriteValue386_Op386MOVWLZX(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWload(v *Value) bool { +func rewriteValue386_Op386MOVWload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6351,7 +6360,7 @@ func rewriteValue386_Op386MOVWload(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWloadidx1(v *Value) bool { +func rewriteValue386_Op386MOVWloadidx1_0(v *Value) bool { // match: (MOVWloadidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) // cond: // result: (MOVWloadidx2 [c] {sym} ptr idx mem) @@ -6490,7 +6499,7 @@ func rewriteValue386_Op386MOVWloadidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWloadidx2(v *Value) bool { +func rewriteValue386_Op386MOVWloadidx2_0(v *Value) bool { // match: (MOVWloadidx2 [c] {sym} (ADDLconst [d] ptr) idx mem) // cond: // result: (MOVWloadidx2 [c+d] {sym} ptr idx mem) @@ -6537,7 +6546,7 @@ func rewriteValue386_Op386MOVWloadidx2(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstore(v *Value) bool { +func rewriteValue386_Op386MOVWstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6833,7 +6842,7 @@ func rewriteValue386_Op386MOVWstore(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstoreconst(v *Value) bool { +func rewriteValue386_Op386MOVWstoreconst_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6989,7 +6998,7 @@ func rewriteValue386_Op386MOVWstoreconst(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool { +func rewriteValue386_Op386MOVWstoreconstidx1_0(v *Value) bool { // match: (MOVWstoreconstidx1 [c] {sym} ptr (SHLLconst [1] idx) mem) // cond: // result: (MOVWstoreconstidx2 [c] {sym} ptr idx mem) @@ -7094,7 +7103,7 @@ func rewriteValue386_Op386MOVWstoreconstidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool { +func rewriteValue386_Op386MOVWstoreconstidx2_0(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreconstidx2 [x] {sym} (ADDLconst [c] ptr) idx mem) @@ -7180,7 +7189,7 @@ func rewriteValue386_Op386MOVWstoreconstidx2(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool { +func rewriteValue386_Op386MOVWstoreidx1_0(v *Value) bool { // match: (MOVWstoreidx1 [c] {sym} ptr (SHLLconst [1] idx) val mem) // cond: // result: (MOVWstoreidx2 [c] {sym} ptr idx val mem) @@ -7521,6 +7530,9 @@ func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValue386_Op386MOVWstoreidx1_10(v *Value) bool { // match: (MOVWstoreidx1 [i] {s} p idx (SHRLconst [j] w) x:(MOVWstoreidx1 [i-2] {s} p idx w0:(SHRLconst [j-16] w) mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVLstoreidx1 [i-2] {s} p idx w0 mem) @@ -7735,7 +7747,7 @@ func rewriteValue386_Op386MOVWstoreidx1(v *Value) bool { } return false } -func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool { +func rewriteValue386_Op386MOVWstoreidx2_0(v *Value) bool { b := v.Block _ = b // match: (MOVWstoreidx2 [c] {sym} (ADDLconst [d] ptr) idx val mem) @@ -7895,7 +7907,7 @@ func rewriteValue386_Op386MOVWstoreidx2(v *Value) bool { } return false } -func rewriteValue386_Op386MULL(v *Value) bool { +func rewriteValue386_Op386MULL_0(v *Value) bool { // match: (MULL x (MOVLconst [c])) // cond: // result: (MULLconst [c] x) @@ -7928,7 +7940,7 @@ func rewriteValue386_Op386MULL(v *Value) bool { } return false } -func rewriteValue386_Op386MULLconst(v *Value) bool { +func rewriteValue386_Op386MULLconst_0(v *Value) bool { b := v.Block _ = b // match: (MULLconst [c] (MULLconst [d] x)) @@ -8069,6 +8081,11 @@ func rewriteValue386_Op386MULLconst(v *Value) bool { 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 x x)) @@ -8231,6 +8248,11 @@ func rewriteValue386_Op386MULLconst(v *Value) bool { 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 [log2(c-8)] x) x) @@ -8315,7 +8337,7 @@ func rewriteValue386_Op386MULLconst(v *Value) bool { } return false } -func rewriteValue386_Op386NEGL(v *Value) bool { +func rewriteValue386_Op386NEGL_0(v *Value) bool { // match: (NEGL (MOVLconst [c])) // cond: // result: (MOVLconst [int64(int32(-c))]) @@ -8331,7 +8353,7 @@ func rewriteValue386_Op386NEGL(v *Value) bool { } return false } -func rewriteValue386_Op386NOTL(v *Value) bool { +func rewriteValue386_Op386NOTL_0(v *Value) bool { // match: (NOTL (MOVLconst [c])) // cond: // result: (MOVLconst [^c]) @@ -8347,7 +8369,7 @@ func rewriteValue386_Op386NOTL(v *Value) bool { } return false } -func rewriteValue386_Op386ORL(v *Value) bool { +func rewriteValue386_Op386ORL_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8601,6 +8623,13 @@ func rewriteValue386_Op386ORL(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValue386_Op386ORL_10(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORL s0:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem)) // cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && s0.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(s0) // result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem) @@ -9186,6 +9215,11 @@ func rewriteValue386_Op386ORL(v *Value) bool { 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 [i0] {s} p idx mem) @@ -9892,6 +9926,11 @@ func rewriteValue386_Op386ORL(v *Value) bool { 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 [i0] {s} p idx mem) @@ -10682,6 +10721,11 @@ func rewriteValue386_Op386ORL(v *Value) bool { 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 [i0] {s} p idx mem) @@ -11472,6 +11516,11 @@ func rewriteValue386_Op386ORL(v *Value) bool { 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 [i0] {s} p idx mem) @@ -11869,7 +11918,7 @@ func rewriteValue386_Op386ORL(v *Value) bool { } return false } -func rewriteValue386_Op386ORLconst(v *Value) bool { +func rewriteValue386_Op386ORLconst_0(v *Value) bool { // match: (ORLconst [c] x) // cond: int32(c)==0 // result: x @@ -11912,7 +11961,7 @@ func rewriteValue386_Op386ORLconst(v *Value) bool { } return false } -func rewriteValue386_Op386ROLBconst(v *Value) bool { +func rewriteValue386_Op386ROLBconst_0(v *Value) bool { // match: (ROLBconst [c] (ROLBconst [d] x)) // cond: // result: (ROLBconst [(c+d)& 7] x) @@ -11944,7 +11993,7 @@ func rewriteValue386_Op386ROLBconst(v *Value) bool { } return false } -func rewriteValue386_Op386ROLLconst(v *Value) bool { +func rewriteValue386_Op386ROLLconst_0(v *Value) bool { // match: (ROLLconst [c] (ROLLconst [d] x)) // cond: // result: (ROLLconst [(c+d)&31] x) @@ -11976,7 +12025,7 @@ func rewriteValue386_Op386ROLLconst(v *Value) bool { } return false } -func rewriteValue386_Op386ROLWconst(v *Value) bool { +func rewriteValue386_Op386ROLWconst_0(v *Value) bool { // match: (ROLWconst [c] (ROLWconst [d] x)) // cond: // result: (ROLWconst [(c+d)&15] x) @@ -12008,7 +12057,7 @@ func rewriteValue386_Op386ROLWconst(v *Value) bool { } return false } -func rewriteValue386_Op386SARB(v *Value) bool { +func rewriteValue386_Op386SARB_0(v *Value) bool { // match: (SARB x (MOVLconst [c])) // cond: // result: (SARBconst [min(c&31,7)] x) @@ -12026,7 +12075,7 @@ func rewriteValue386_Op386SARB(v *Value) bool { } return false } -func rewriteValue386_Op386SARBconst(v *Value) bool { +func rewriteValue386_Op386SARBconst_0(v *Value) bool { // match: (SARBconst x [0]) // cond: // result: x @@ -12056,7 +12105,7 @@ func rewriteValue386_Op386SARBconst(v *Value) bool { } return false } -func rewriteValue386_Op386SARL(v *Value) bool { +func rewriteValue386_Op386SARL_0(v *Value) bool { // match: (SARL x (MOVLconst [c])) // cond: // result: (SARLconst [c&31] x) @@ -12092,7 +12141,7 @@ func rewriteValue386_Op386SARL(v *Value) bool { } return false } -func rewriteValue386_Op386SARLconst(v *Value) bool { +func rewriteValue386_Op386SARLconst_0(v *Value) bool { // match: (SARLconst x [0]) // cond: // result: x @@ -12122,7 +12171,7 @@ func rewriteValue386_Op386SARLconst(v *Value) bool { } return false } -func rewriteValue386_Op386SARW(v *Value) bool { +func rewriteValue386_Op386SARW_0(v *Value) bool { // match: (SARW x (MOVLconst [c])) // cond: // result: (SARWconst [min(c&31,15)] x) @@ -12140,7 +12189,7 @@ func rewriteValue386_Op386SARW(v *Value) bool { } return false } -func rewriteValue386_Op386SARWconst(v *Value) bool { +func rewriteValue386_Op386SARWconst_0(v *Value) bool { // match: (SARWconst x [0]) // cond: // result: x @@ -12170,7 +12219,7 @@ func rewriteValue386_Op386SARWconst(v *Value) bool { } return false } -func rewriteValue386_Op386SBBL(v *Value) bool { +func rewriteValue386_Op386SBBL_0(v *Value) bool { // match: (SBBL x (MOVLconst [c]) f) // cond: // result: (SBBLconst [c] x f) @@ -12190,7 +12239,7 @@ func rewriteValue386_Op386SBBL(v *Value) bool { } return false } -func rewriteValue386_Op386SBBLcarrymask(v *Value) bool { +func rewriteValue386_Op386SBBLcarrymask_0(v *Value) bool { // match: (SBBLcarrymask (FlagEQ)) // cond: // result: (MOVLconst [0]) @@ -12253,7 +12302,7 @@ func rewriteValue386_Op386SBBLcarrymask(v *Value) bool { } return false } -func rewriteValue386_Op386SETA(v *Value) bool { +func rewriteValue386_Op386SETA_0(v *Value) bool { // match: (SETA (InvertFlags x)) // cond: // result: (SETB x) @@ -12329,7 +12378,7 @@ func rewriteValue386_Op386SETA(v *Value) bool { } return false } -func rewriteValue386_Op386SETAE(v *Value) bool { +func rewriteValue386_Op386SETAE_0(v *Value) bool { // match: (SETAE (InvertFlags x)) // cond: // result: (SETBE x) @@ -12405,7 +12454,7 @@ func rewriteValue386_Op386SETAE(v *Value) bool { } return false } -func rewriteValue386_Op386SETB(v *Value) bool { +func rewriteValue386_Op386SETB_0(v *Value) bool { // match: (SETB (InvertFlags x)) // cond: // result: (SETA x) @@ -12481,7 +12530,7 @@ func rewriteValue386_Op386SETB(v *Value) bool { } return false } -func rewriteValue386_Op386SETBE(v *Value) bool { +func rewriteValue386_Op386SETBE_0(v *Value) bool { // match: (SETBE (InvertFlags x)) // cond: // result: (SETAE x) @@ -12557,7 +12606,7 @@ func rewriteValue386_Op386SETBE(v *Value) bool { } return false } -func rewriteValue386_Op386SETEQ(v *Value) bool { +func rewriteValue386_Op386SETEQ_0(v *Value) bool { // match: (SETEQ (InvertFlags x)) // cond: // result: (SETEQ x) @@ -12633,7 +12682,7 @@ func rewriteValue386_Op386SETEQ(v *Value) bool { } return false } -func rewriteValue386_Op386SETG(v *Value) bool { +func rewriteValue386_Op386SETG_0(v *Value) bool { // match: (SETG (InvertFlags x)) // cond: // result: (SETL x) @@ -12709,7 +12758,7 @@ func rewriteValue386_Op386SETG(v *Value) bool { } return false } -func rewriteValue386_Op386SETGE(v *Value) bool { +func rewriteValue386_Op386SETGE_0(v *Value) bool { // match: (SETGE (InvertFlags x)) // cond: // result: (SETLE x) @@ -12785,7 +12834,7 @@ func rewriteValue386_Op386SETGE(v *Value) bool { } return false } -func rewriteValue386_Op386SETL(v *Value) bool { +func rewriteValue386_Op386SETL_0(v *Value) bool { // match: (SETL (InvertFlags x)) // cond: // result: (SETG x) @@ -12861,7 +12910,7 @@ func rewriteValue386_Op386SETL(v *Value) bool { } return false } -func rewriteValue386_Op386SETLE(v *Value) bool { +func rewriteValue386_Op386SETLE_0(v *Value) bool { // match: (SETLE (InvertFlags x)) // cond: // result: (SETGE x) @@ -12937,7 +12986,7 @@ func rewriteValue386_Op386SETLE(v *Value) bool { } return false } -func rewriteValue386_Op386SETNE(v *Value) bool { +func rewriteValue386_Op386SETNE_0(v *Value) bool { // match: (SETNE (InvertFlags x)) // cond: // result: (SETNE x) @@ -13013,7 +13062,7 @@ func rewriteValue386_Op386SETNE(v *Value) bool { } return false } -func rewriteValue386_Op386SHLL(v *Value) bool { +func rewriteValue386_Op386SHLL_0(v *Value) bool { // match: (SHLL x (MOVLconst [c])) // cond: // result: (SHLLconst [c&31] x) @@ -13049,7 +13098,7 @@ func rewriteValue386_Op386SHLL(v *Value) bool { } return false } -func rewriteValue386_Op386SHLLconst(v *Value) bool { +func rewriteValue386_Op386SHLLconst_0(v *Value) bool { // match: (SHLLconst x [0]) // cond: // result: x @@ -13065,7 +13114,7 @@ func rewriteValue386_Op386SHLLconst(v *Value) bool { } return false } -func rewriteValue386_Op386SHRB(v *Value) bool { +func rewriteValue386_Op386SHRB_0(v *Value) bool { // match: (SHRB x (MOVLconst [c])) // cond: c&31 < 8 // result: (SHRBconst [c&31] x) @@ -13102,7 +13151,7 @@ func rewriteValue386_Op386SHRB(v *Value) bool { } return false } -func rewriteValue386_Op386SHRBconst(v *Value) bool { +func rewriteValue386_Op386SHRBconst_0(v *Value) bool { // match: (SHRBconst x [0]) // cond: // result: x @@ -13118,7 +13167,7 @@ func rewriteValue386_Op386SHRBconst(v *Value) bool { } return false } -func rewriteValue386_Op386SHRL(v *Value) bool { +func rewriteValue386_Op386SHRL_0(v *Value) bool { // match: (SHRL x (MOVLconst [c])) // cond: // result: (SHRLconst [c&31] x) @@ -13154,7 +13203,7 @@ func rewriteValue386_Op386SHRL(v *Value) bool { } return false } -func rewriteValue386_Op386SHRLconst(v *Value) bool { +func rewriteValue386_Op386SHRLconst_0(v *Value) bool { // match: (SHRLconst x [0]) // cond: // result: x @@ -13170,7 +13219,7 @@ func rewriteValue386_Op386SHRLconst(v *Value) bool { } return false } -func rewriteValue386_Op386SHRW(v *Value) bool { +func rewriteValue386_Op386SHRW_0(v *Value) bool { // match: (SHRW x (MOVLconst [c])) // cond: c&31 < 16 // result: (SHRWconst [c&31] x) @@ -13207,7 +13256,7 @@ func rewriteValue386_Op386SHRW(v *Value) bool { } return false } -func rewriteValue386_Op386SHRWconst(v *Value) bool { +func rewriteValue386_Op386SHRWconst_0(v *Value) bool { // match: (SHRWconst x [0]) // cond: // result: x @@ -13223,7 +13272,7 @@ func rewriteValue386_Op386SHRWconst(v *Value) bool { } return false } -func rewriteValue386_Op386SUBL(v *Value) bool { +func rewriteValue386_Op386SUBL_0(v *Value) bool { b := v.Block _ = b // match: (SUBL x (MOVLconst [c])) @@ -13272,7 +13321,7 @@ func rewriteValue386_Op386SUBL(v *Value) bool { } return false } -func rewriteValue386_Op386SUBLcarry(v *Value) bool { +func rewriteValue386_Op386SUBLcarry_0(v *Value) bool { // match: (SUBLcarry x (MOVLconst [c])) // cond: // result: (SUBLconstcarry [c] x) @@ -13290,7 +13339,7 @@ func rewriteValue386_Op386SUBLcarry(v *Value) bool { } return false } -func rewriteValue386_Op386SUBLconst(v *Value) bool { +func rewriteValue386_Op386SUBLconst_0(v *Value) bool { // match: (SUBLconst [c] x) // cond: int32(c) == 0 // result: x @@ -13317,7 +13366,7 @@ func rewriteValue386_Op386SUBLconst(v *Value) bool { return true } } -func rewriteValue386_Op386XORL(v *Value) bool { +func rewriteValue386_Op386XORL_0(v *Value) bool { // match: (XORL x (MOVLconst [c])) // cond: // result: (XORLconst [c] x) @@ -13522,7 +13571,7 @@ func rewriteValue386_Op386XORL(v *Value) bool { } return false } -func rewriteValue386_Op386XORLconst(v *Value) bool { +func rewriteValue386_Op386XORLconst_0(v *Value) bool { // match: (XORLconst [c] (XORLconst [d] x)) // cond: // result: (XORLconst [c ^ d] x) @@ -13569,7 +13618,7 @@ func rewriteValue386_Op386XORLconst(v *Value) bool { } return false } -func rewriteValue386_OpAdd16(v *Value) bool { +func rewriteValue386_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDL x y) @@ -13582,7 +13631,7 @@ func rewriteValue386_OpAdd16(v *Value) bool { return true } } -func rewriteValue386_OpAdd32(v *Value) bool { +func rewriteValue386_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDL x y) @@ -13595,7 +13644,7 @@ func rewriteValue386_OpAdd32(v *Value) bool { return true } } -func rewriteValue386_OpAdd32F(v *Value) bool { +func rewriteValue386_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDSS x y) @@ -13608,7 +13657,7 @@ func rewriteValue386_OpAdd32F(v *Value) bool { return true } } -func rewriteValue386_OpAdd32carry(v *Value) bool { +func rewriteValue386_OpAdd32carry_0(v *Value) bool { // match: (Add32carry x y) // cond: // result: (ADDLcarry x y) @@ -13621,7 +13670,7 @@ func rewriteValue386_OpAdd32carry(v *Value) bool { return true } } -func rewriteValue386_OpAdd32withcarry(v *Value) bool { +func rewriteValue386_OpAdd32withcarry_0(v *Value) bool { // match: (Add32withcarry x y c) // cond: // result: (ADCL x y c) @@ -13636,7 +13685,7 @@ func rewriteValue386_OpAdd32withcarry(v *Value) bool { return true } } -func rewriteValue386_OpAdd64F(v *Value) bool { +func rewriteValue386_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDSD x y) @@ -13649,7 +13698,7 @@ func rewriteValue386_OpAdd64F(v *Value) bool { return true } } -func rewriteValue386_OpAdd8(v *Value) bool { +func rewriteValue386_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDL x y) @@ -13662,7 +13711,7 @@ func rewriteValue386_OpAdd8(v *Value) bool { return true } } -func rewriteValue386_OpAddPtr(v *Value) bool { +func rewriteValue386_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADDL x y) @@ -13675,7 +13724,7 @@ func rewriteValue386_OpAddPtr(v *Value) bool { return true } } -func rewriteValue386_OpAddr(v *Value) bool { +func rewriteValue386_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (LEAL {sym} base) @@ -13688,7 +13737,7 @@ func rewriteValue386_OpAddr(v *Value) bool { return true } } -func rewriteValue386_OpAnd16(v *Value) bool { +func rewriteValue386_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDL x y) @@ -13701,7 +13750,7 @@ func rewriteValue386_OpAnd16(v *Value) bool { return true } } -func rewriteValue386_OpAnd32(v *Value) bool { +func rewriteValue386_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDL x y) @@ -13714,7 +13763,7 @@ func rewriteValue386_OpAnd32(v *Value) bool { return true } } -func rewriteValue386_OpAnd8(v *Value) bool { +func rewriteValue386_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDL x y) @@ -13727,7 +13776,7 @@ func rewriteValue386_OpAnd8(v *Value) bool { return true } } -func rewriteValue386_OpAndB(v *Value) bool { +func rewriteValue386_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDL x y) @@ -13740,7 +13789,7 @@ func rewriteValue386_OpAndB(v *Value) bool { return true } } -func rewriteValue386_OpAvg32u(v *Value) bool { +func rewriteValue386_OpAvg32u_0(v *Value) bool { // match: (Avg32u x y) // cond: // result: (AVGLU x y) @@ -13753,7 +13802,7 @@ func rewriteValue386_OpAvg32u(v *Value) bool { return true } } -func rewriteValue386_OpBswap32(v *Value) bool { +func rewriteValue386_OpBswap32_0(v *Value) bool { // match: (Bswap32 x) // cond: // result: (BSWAPL x) @@ -13764,7 +13813,7 @@ func rewriteValue386_OpBswap32(v *Value) bool { return true } } -func rewriteValue386_OpClosureCall(v *Value) bool { +func rewriteValue386_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -13781,7 +13830,7 @@ func rewriteValue386_OpClosureCall(v *Value) bool { return true } } -func rewriteValue386_OpCom16(v *Value) bool { +func rewriteValue386_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTL x) @@ -13792,7 +13841,7 @@ func rewriteValue386_OpCom16(v *Value) bool { return true } } -func rewriteValue386_OpCom32(v *Value) bool { +func rewriteValue386_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTL x) @@ -13803,7 +13852,7 @@ func rewriteValue386_OpCom32(v *Value) bool { return true } } -func rewriteValue386_OpCom8(v *Value) bool { +func rewriteValue386_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTL x) @@ -13814,7 +13863,7 @@ func rewriteValue386_OpCom8(v *Value) bool { return true } } -func rewriteValue386_OpConst16(v *Value) bool { +func rewriteValue386_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVLconst [val]) @@ -13825,7 +13874,7 @@ func rewriteValue386_OpConst16(v *Value) bool { return true } } -func rewriteValue386_OpConst32(v *Value) bool { +func rewriteValue386_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVLconst [val]) @@ -13836,7 +13885,7 @@ func rewriteValue386_OpConst32(v *Value) bool { return true } } -func rewriteValue386_OpConst32F(v *Value) bool { +func rewriteValue386_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVSSconst [val]) @@ -13847,7 +13896,7 @@ func rewriteValue386_OpConst32F(v *Value) bool { return true } } -func rewriteValue386_OpConst64F(v *Value) bool { +func rewriteValue386_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVSDconst [val]) @@ -13858,7 +13907,7 @@ func rewriteValue386_OpConst64F(v *Value) bool { return true } } -func rewriteValue386_OpConst8(v *Value) bool { +func rewriteValue386_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVLconst [val]) @@ -13869,7 +13918,7 @@ func rewriteValue386_OpConst8(v *Value) bool { return true } } -func rewriteValue386_OpConstBool(v *Value) bool { +func rewriteValue386_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVLconst [b]) @@ -13880,7 +13929,7 @@ func rewriteValue386_OpConstBool(v *Value) bool { return true } } -func rewriteValue386_OpConstNil(v *Value) bool { +func rewriteValue386_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVLconst [0]) @@ -13890,7 +13939,7 @@ func rewriteValue386_OpConstNil(v *Value) bool { return true } } -func rewriteValue386_OpConvert(v *Value) bool { +func rewriteValue386_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVLconvert x mem) @@ -13905,7 +13954,7 @@ func rewriteValue386_OpConvert(v *Value) bool { return true } } -func rewriteValue386_OpCvt32Fto32(v *Value) bool { +func rewriteValue386_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CVTTSS2SL x) @@ -13916,7 +13965,7 @@ func rewriteValue386_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValue386_OpCvt32Fto64F(v *Value) bool { +func rewriteValue386_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (CVTSS2SD x) @@ -13927,7 +13976,7 @@ func rewriteValue386_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValue386_OpCvt32to32F(v *Value) bool { +func rewriteValue386_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CVTSL2SS x) @@ -13938,7 +13987,7 @@ func rewriteValue386_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValue386_OpCvt32to64F(v *Value) bool { +func rewriteValue386_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CVTSL2SD x) @@ -13949,7 +13998,7 @@ func rewriteValue386_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValue386_OpCvt64Fto32(v *Value) bool { +func rewriteValue386_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CVTTSD2SL x) @@ -13960,7 +14009,7 @@ func rewriteValue386_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValue386_OpCvt64Fto32F(v *Value) bool { +func rewriteValue386_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (CVTSD2SS x) @@ -13971,7 +14020,7 @@ func rewriteValue386_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValue386_OpDiv16(v *Value) bool { +func rewriteValue386_OpDiv16_0(v *Value) bool { // match: (Div16 x y) // cond: // result: (DIVW x y) @@ -13984,7 +14033,7 @@ func rewriteValue386_OpDiv16(v *Value) bool { return true } } -func rewriteValue386_OpDiv16u(v *Value) bool { +func rewriteValue386_OpDiv16u_0(v *Value) bool { // match: (Div16u x y) // cond: // result: (DIVWU x y) @@ -13997,7 +14046,7 @@ func rewriteValue386_OpDiv16u(v *Value) bool { return true } } -func rewriteValue386_OpDiv32(v *Value) bool { +func rewriteValue386_OpDiv32_0(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVL x y) @@ -14010,7 +14059,7 @@ func rewriteValue386_OpDiv32(v *Value) bool { return true } } -func rewriteValue386_OpDiv32F(v *Value) bool { +func rewriteValue386_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVSS x y) @@ -14023,7 +14072,7 @@ func rewriteValue386_OpDiv32F(v *Value) bool { return true } } -func rewriteValue386_OpDiv32u(v *Value) bool { +func rewriteValue386_OpDiv32u_0(v *Value) bool { // match: (Div32u x y) // cond: // result: (DIVLU x y) @@ -14036,7 +14085,7 @@ func rewriteValue386_OpDiv32u(v *Value) bool { return true } } -func rewriteValue386_OpDiv64F(v *Value) bool { +func rewriteValue386_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVSD x y) @@ -14049,7 +14098,7 @@ func rewriteValue386_OpDiv64F(v *Value) bool { return true } } -func rewriteValue386_OpDiv8(v *Value) bool { +func rewriteValue386_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14070,7 +14119,7 @@ func rewriteValue386_OpDiv8(v *Value) bool { return true } } -func rewriteValue386_OpDiv8u(v *Value) bool { +func rewriteValue386_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14091,7 +14140,7 @@ func rewriteValue386_OpDiv8u(v *Value) bool { return true } } -func rewriteValue386_OpEq16(v *Value) bool { +func rewriteValue386_OpEq16_0(v *Value) bool { b := v.Block _ = b // match: (Eq16 x y) @@ -14108,7 +14157,7 @@ func rewriteValue386_OpEq16(v *Value) bool { return true } } -func rewriteValue386_OpEq32(v *Value) bool { +func rewriteValue386_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -14125,7 +14174,7 @@ func rewriteValue386_OpEq32(v *Value) bool { return true } } -func rewriteValue386_OpEq32F(v *Value) bool { +func rewriteValue386_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -14142,7 +14191,7 @@ func rewriteValue386_OpEq32F(v *Value) bool { return true } } -func rewriteValue386_OpEq64F(v *Value) bool { +func rewriteValue386_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -14159,7 +14208,7 @@ func rewriteValue386_OpEq64F(v *Value) bool { return true } } -func rewriteValue386_OpEq8(v *Value) bool { +func rewriteValue386_OpEq8_0(v *Value) bool { b := v.Block _ = b // match: (Eq8 x y) @@ -14176,7 +14225,7 @@ func rewriteValue386_OpEq8(v *Value) bool { return true } } -func rewriteValue386_OpEqB(v *Value) bool { +func rewriteValue386_OpEqB_0(v *Value) bool { b := v.Block _ = b // match: (EqB x y) @@ -14193,7 +14242,7 @@ func rewriteValue386_OpEqB(v *Value) bool { return true } } -func rewriteValue386_OpEqPtr(v *Value) bool { +func rewriteValue386_OpEqPtr_0(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -14210,7 +14259,7 @@ func rewriteValue386_OpEqPtr(v *Value) bool { return true } } -func rewriteValue386_OpGeq16(v *Value) bool { +func rewriteValue386_OpGeq16_0(v *Value) bool { b := v.Block _ = b // match: (Geq16 x y) @@ -14227,7 +14276,7 @@ func rewriteValue386_OpGeq16(v *Value) bool { return true } } -func rewriteValue386_OpGeq16U(v *Value) bool { +func rewriteValue386_OpGeq16U_0(v *Value) bool { b := v.Block _ = b // match: (Geq16U x y) @@ -14244,7 +14293,7 @@ func rewriteValue386_OpGeq16U(v *Value) bool { return true } } -func rewriteValue386_OpGeq32(v *Value) bool { +func rewriteValue386_OpGeq32_0(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -14261,7 +14310,7 @@ func rewriteValue386_OpGeq32(v *Value) bool { return true } } -func rewriteValue386_OpGeq32F(v *Value) bool { +func rewriteValue386_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -14278,7 +14327,7 @@ func rewriteValue386_OpGeq32F(v *Value) bool { return true } } -func rewriteValue386_OpGeq32U(v *Value) bool { +func rewriteValue386_OpGeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -14295,7 +14344,7 @@ func rewriteValue386_OpGeq32U(v *Value) bool { return true } } -func rewriteValue386_OpGeq64F(v *Value) bool { +func rewriteValue386_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -14312,7 +14361,7 @@ func rewriteValue386_OpGeq64F(v *Value) bool { return true } } -func rewriteValue386_OpGeq8(v *Value) bool { +func rewriteValue386_OpGeq8_0(v *Value) bool { b := v.Block _ = b // match: (Geq8 x y) @@ -14329,7 +14378,7 @@ func rewriteValue386_OpGeq8(v *Value) bool { return true } } -func rewriteValue386_OpGeq8U(v *Value) bool { +func rewriteValue386_OpGeq8U_0(v *Value) bool { b := v.Block _ = b // match: (Geq8U x y) @@ -14346,7 +14395,7 @@ func rewriteValue386_OpGeq8U(v *Value) bool { return true } } -func rewriteValue386_OpGetClosurePtr(v *Value) bool { +func rewriteValue386_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -14355,7 +14404,7 @@ func rewriteValue386_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValue386_OpGetG(v *Value) bool { +func rewriteValue386_OpGetG_0(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -14366,7 +14415,7 @@ func rewriteValue386_OpGetG(v *Value) bool { return true } } -func rewriteValue386_OpGreater16(v *Value) bool { +func rewriteValue386_OpGreater16_0(v *Value) bool { b := v.Block _ = b // match: (Greater16 x y) @@ -14383,7 +14432,7 @@ func rewriteValue386_OpGreater16(v *Value) bool { return true } } -func rewriteValue386_OpGreater16U(v *Value) bool { +func rewriteValue386_OpGreater16U_0(v *Value) bool { b := v.Block _ = b // match: (Greater16U x y) @@ -14400,7 +14449,7 @@ func rewriteValue386_OpGreater16U(v *Value) bool { return true } } -func rewriteValue386_OpGreater32(v *Value) bool { +func rewriteValue386_OpGreater32_0(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -14417,7 +14466,7 @@ func rewriteValue386_OpGreater32(v *Value) bool { return true } } -func rewriteValue386_OpGreater32F(v *Value) bool { +func rewriteValue386_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -14434,7 +14483,7 @@ func rewriteValue386_OpGreater32F(v *Value) bool { return true } } -func rewriteValue386_OpGreater32U(v *Value) bool { +func rewriteValue386_OpGreater32U_0(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -14451,7 +14500,7 @@ func rewriteValue386_OpGreater32U(v *Value) bool { return true } } -func rewriteValue386_OpGreater64F(v *Value) bool { +func rewriteValue386_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -14468,7 +14517,7 @@ func rewriteValue386_OpGreater64F(v *Value) bool { return true } } -func rewriteValue386_OpGreater8(v *Value) bool { +func rewriteValue386_OpGreater8_0(v *Value) bool { b := v.Block _ = b // match: (Greater8 x y) @@ -14485,7 +14534,7 @@ func rewriteValue386_OpGreater8(v *Value) bool { return true } } -func rewriteValue386_OpGreater8U(v *Value) bool { +func rewriteValue386_OpGreater8U_0(v *Value) bool { b := v.Block _ = b // match: (Greater8U x y) @@ -14502,7 +14551,7 @@ func rewriteValue386_OpGreater8U(v *Value) bool { return true } } -func rewriteValue386_OpHmul32(v *Value) bool { +func rewriteValue386_OpHmul32_0(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMULL x y) @@ -14515,7 +14564,7 @@ func rewriteValue386_OpHmul32(v *Value) bool { return true } } -func rewriteValue386_OpHmul32u(v *Value) bool { +func rewriteValue386_OpHmul32u_0(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULLU x y) @@ -14528,7 +14577,7 @@ func rewriteValue386_OpHmul32u(v *Value) bool { return true } } -func rewriteValue386_OpInterCall(v *Value) bool { +func rewriteValue386_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -14543,7 +14592,7 @@ func rewriteValue386_OpInterCall(v *Value) bool { return true } } -func rewriteValue386_OpIsInBounds(v *Value) bool { +func rewriteValue386_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -14560,7 +14609,7 @@ func rewriteValue386_OpIsInBounds(v *Value) bool { return true } } -func rewriteValue386_OpIsNonNil(v *Value) bool { +func rewriteValue386_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b // match: (IsNonNil p) @@ -14576,7 +14625,7 @@ func rewriteValue386_OpIsNonNil(v *Value) bool { return true } } -func rewriteValue386_OpIsSliceInBounds(v *Value) bool { +func rewriteValue386_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -14593,7 +14642,7 @@ func rewriteValue386_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValue386_OpLeq16(v *Value) bool { +func rewriteValue386_OpLeq16_0(v *Value) bool { b := v.Block _ = b // match: (Leq16 x y) @@ -14610,7 +14659,7 @@ func rewriteValue386_OpLeq16(v *Value) bool { return true } } -func rewriteValue386_OpLeq16U(v *Value) bool { +func rewriteValue386_OpLeq16U_0(v *Value) bool { b := v.Block _ = b // match: (Leq16U x y) @@ -14627,7 +14676,7 @@ func rewriteValue386_OpLeq16U(v *Value) bool { return true } } -func rewriteValue386_OpLeq32(v *Value) bool { +func rewriteValue386_OpLeq32_0(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -14644,7 +14693,7 @@ func rewriteValue386_OpLeq32(v *Value) bool { return true } } -func rewriteValue386_OpLeq32F(v *Value) bool { +func rewriteValue386_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -14661,7 +14710,7 @@ func rewriteValue386_OpLeq32F(v *Value) bool { return true } } -func rewriteValue386_OpLeq32U(v *Value) bool { +func rewriteValue386_OpLeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -14678,7 +14727,7 @@ func rewriteValue386_OpLeq32U(v *Value) bool { return true } } -func rewriteValue386_OpLeq64F(v *Value) bool { +func rewriteValue386_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -14695,7 +14744,7 @@ func rewriteValue386_OpLeq64F(v *Value) bool { return true } } -func rewriteValue386_OpLeq8(v *Value) bool { +func rewriteValue386_OpLeq8_0(v *Value) bool { b := v.Block _ = b // match: (Leq8 x y) @@ -14712,7 +14761,7 @@ func rewriteValue386_OpLeq8(v *Value) bool { return true } } -func rewriteValue386_OpLeq8U(v *Value) bool { +func rewriteValue386_OpLeq8U_0(v *Value) bool { b := v.Block _ = b // match: (Leq8U x y) @@ -14729,7 +14778,7 @@ func rewriteValue386_OpLeq8U(v *Value) bool { return true } } -func rewriteValue386_OpLess16(v *Value) bool { +func rewriteValue386_OpLess16_0(v *Value) bool { b := v.Block _ = b // match: (Less16 x y) @@ -14746,7 +14795,7 @@ func rewriteValue386_OpLess16(v *Value) bool { return true } } -func rewriteValue386_OpLess16U(v *Value) bool { +func rewriteValue386_OpLess16U_0(v *Value) bool { b := v.Block _ = b // match: (Less16U x y) @@ -14763,7 +14812,7 @@ func rewriteValue386_OpLess16U(v *Value) bool { return true } } -func rewriteValue386_OpLess32(v *Value) bool { +func rewriteValue386_OpLess32_0(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -14780,7 +14829,7 @@ func rewriteValue386_OpLess32(v *Value) bool { return true } } -func rewriteValue386_OpLess32F(v *Value) bool { +func rewriteValue386_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -14797,7 +14846,7 @@ func rewriteValue386_OpLess32F(v *Value) bool { return true } } -func rewriteValue386_OpLess32U(v *Value) bool { +func rewriteValue386_OpLess32U_0(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -14814,7 +14863,7 @@ func rewriteValue386_OpLess32U(v *Value) bool { return true } } -func rewriteValue386_OpLess64F(v *Value) bool { +func rewriteValue386_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -14831,7 +14880,7 @@ func rewriteValue386_OpLess64F(v *Value) bool { return true } } -func rewriteValue386_OpLess8(v *Value) bool { +func rewriteValue386_OpLess8_0(v *Value) bool { b := v.Block _ = b // match: (Less8 x y) @@ -14848,7 +14897,7 @@ func rewriteValue386_OpLess8(v *Value) bool { return true } } -func rewriteValue386_OpLess8U(v *Value) bool { +func rewriteValue386_OpLess8U_0(v *Value) bool { b := v.Block _ = b // match: (Less8U x y) @@ -14865,7 +14914,7 @@ func rewriteValue386_OpLess8U(v *Value) bool { return true } } -func rewriteValue386_OpLoad(v *Value) bool { +func rewriteValue386_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: (is32BitInt(t) || isPtr(t)) // result: (MOVLload ptr mem) @@ -14943,7 +14992,7 @@ func rewriteValue386_OpLoad(v *Value) bool { } return false } -func rewriteValue386_OpLsh16x16(v *Value) bool { +func rewriteValue386_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 x y) @@ -14967,7 +15016,7 @@ func rewriteValue386_OpLsh16x16(v *Value) bool { return true } } -func rewriteValue386_OpLsh16x32(v *Value) bool { +func rewriteValue386_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x y) @@ -14991,7 +15040,7 @@ func rewriteValue386_OpLsh16x32(v *Value) bool { return true } } -func rewriteValue386_OpLsh16x64(v *Value) bool { +func rewriteValue386_OpLsh16x64_0(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SHLLconst x [c]) @@ -15028,7 +15077,7 @@ func rewriteValue386_OpLsh16x64(v *Value) bool { } return false } -func rewriteValue386_OpLsh16x8(v *Value) bool { +func rewriteValue386_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 x y) @@ -15052,7 +15101,7 @@ func rewriteValue386_OpLsh16x8(v *Value) bool { return true } } -func rewriteValue386_OpLsh32x16(v *Value) bool { +func rewriteValue386_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 x y) @@ -15076,7 +15125,7 @@ func rewriteValue386_OpLsh32x16(v *Value) bool { return true } } -func rewriteValue386_OpLsh32x32(v *Value) bool { +func rewriteValue386_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x y) @@ -15100,7 +15149,7 @@ func rewriteValue386_OpLsh32x32(v *Value) bool { return true } } -func rewriteValue386_OpLsh32x64(v *Value) bool { +func rewriteValue386_OpLsh32x64_0(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SHLLconst x [c]) @@ -15137,7 +15186,7 @@ func rewriteValue386_OpLsh32x64(v *Value) bool { } return false } -func rewriteValue386_OpLsh32x8(v *Value) bool { +func rewriteValue386_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 x y) @@ -15161,7 +15210,7 @@ func rewriteValue386_OpLsh32x8(v *Value) bool { return true } } -func rewriteValue386_OpLsh8x16(v *Value) bool { +func rewriteValue386_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 x y) @@ -15185,7 +15234,7 @@ func rewriteValue386_OpLsh8x16(v *Value) bool { return true } } -func rewriteValue386_OpLsh8x32(v *Value) bool { +func rewriteValue386_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x y) @@ -15209,7 +15258,7 @@ func rewriteValue386_OpLsh8x32(v *Value) bool { return true } } -func rewriteValue386_OpLsh8x64(v *Value) bool { +func rewriteValue386_OpLsh8x64_0(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SHLLconst x [c]) @@ -15246,7 +15295,7 @@ func rewriteValue386_OpLsh8x64(v *Value) bool { } return false } -func rewriteValue386_OpLsh8x8(v *Value) bool { +func rewriteValue386_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 x y) @@ -15270,7 +15319,7 @@ func rewriteValue386_OpLsh8x8(v *Value) bool { return true } } -func rewriteValue386_OpMod16(v *Value) bool { +func rewriteValue386_OpMod16_0(v *Value) bool { // match: (Mod16 x y) // cond: // result: (MODW x y) @@ -15283,7 +15332,7 @@ func rewriteValue386_OpMod16(v *Value) bool { return true } } -func rewriteValue386_OpMod16u(v *Value) bool { +func rewriteValue386_OpMod16u_0(v *Value) bool { // match: (Mod16u x y) // cond: // result: (MODWU x y) @@ -15296,7 +15345,7 @@ func rewriteValue386_OpMod16u(v *Value) bool { return true } } -func rewriteValue386_OpMod32(v *Value) bool { +func rewriteValue386_OpMod32_0(v *Value) bool { // match: (Mod32 x y) // cond: // result: (MODL x y) @@ -15309,7 +15358,7 @@ func rewriteValue386_OpMod32(v *Value) bool { return true } } -func rewriteValue386_OpMod32u(v *Value) bool { +func rewriteValue386_OpMod32u_0(v *Value) bool { // match: (Mod32u x y) // cond: // result: (MODLU x y) @@ -15322,7 +15371,7 @@ func rewriteValue386_OpMod32u(v *Value) bool { return true } } -func rewriteValue386_OpMod8(v *Value) bool { +func rewriteValue386_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15343,7 +15392,7 @@ func rewriteValue386_OpMod8(v *Value) bool { return true } } -func rewriteValue386_OpMod8u(v *Value) bool { +func rewriteValue386_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15364,11 +15413,9 @@ func rewriteValue386_OpMod8u(v *Value) bool { return true } } -func rewriteValue386_OpMove(v *Value) bool { +func rewriteValue386_OpMove_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Move [0] _ _ mem) @@ -15612,6 +15659,15 @@ func rewriteValue386_OpMove(v *Value) bool { v.AddArg(v2) return true } + return false +} +func rewriteValue386_OpMove_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Move [s] dst src mem) // cond: s > 8 && s <= 4*128 && s%4 == 0 && !config.noDuffDevice // result: (DUFFCOPY [10*(128-s/4)] dst src mem) @@ -15652,7 +15708,7 @@ func rewriteValue386_OpMove(v *Value) bool { } return false } -func rewriteValue386_OpMul16(v *Value) bool { +func rewriteValue386_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULL x y) @@ -15665,7 +15721,7 @@ func rewriteValue386_OpMul16(v *Value) bool { return true } } -func rewriteValue386_OpMul32(v *Value) bool { +func rewriteValue386_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULL x y) @@ -15678,7 +15734,7 @@ func rewriteValue386_OpMul32(v *Value) bool { return true } } -func rewriteValue386_OpMul32F(v *Value) bool { +func rewriteValue386_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULSS x y) @@ -15691,7 +15747,7 @@ func rewriteValue386_OpMul32F(v *Value) bool { return true } } -func rewriteValue386_OpMul32uhilo(v *Value) bool { +func rewriteValue386_OpMul32uhilo_0(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULLQU x y) @@ -15704,7 +15760,7 @@ func rewriteValue386_OpMul32uhilo(v *Value) bool { return true } } -func rewriteValue386_OpMul64F(v *Value) bool { +func rewriteValue386_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULSD x y) @@ -15717,7 +15773,7 @@ func rewriteValue386_OpMul64F(v *Value) bool { return true } } -func rewriteValue386_OpMul8(v *Value) bool { +func rewriteValue386_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULL x y) @@ -15730,7 +15786,7 @@ func rewriteValue386_OpMul8(v *Value) bool { return true } } -func rewriteValue386_OpNeg16(v *Value) bool { +func rewriteValue386_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGL x) @@ -15741,7 +15797,7 @@ func rewriteValue386_OpNeg16(v *Value) bool { return true } } -func rewriteValue386_OpNeg32(v *Value) bool { +func rewriteValue386_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGL x) @@ -15752,7 +15808,7 @@ func rewriteValue386_OpNeg32(v *Value) bool { return true } } -func rewriteValue386_OpNeg32F(v *Value) bool { +func rewriteValue386_OpNeg32F_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -15788,7 +15844,7 @@ func rewriteValue386_OpNeg32F(v *Value) bool { } return false } -func rewriteValue386_OpNeg64F(v *Value) bool { +func rewriteValue386_OpNeg64F_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -15824,7 +15880,7 @@ func rewriteValue386_OpNeg64F(v *Value) bool { } return false } -func rewriteValue386_OpNeg8(v *Value) bool { +func rewriteValue386_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGL x) @@ -15835,7 +15891,7 @@ func rewriteValue386_OpNeg8(v *Value) bool { return true } } -func rewriteValue386_OpNeq16(v *Value) bool { +func rewriteValue386_OpNeq16_0(v *Value) bool { b := v.Block _ = b // match: (Neq16 x y) @@ -15852,7 +15908,7 @@ func rewriteValue386_OpNeq16(v *Value) bool { return true } } -func rewriteValue386_OpNeq32(v *Value) bool { +func rewriteValue386_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -15869,7 +15925,7 @@ func rewriteValue386_OpNeq32(v *Value) bool { return true } } -func rewriteValue386_OpNeq32F(v *Value) bool { +func rewriteValue386_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -15886,7 +15942,7 @@ func rewriteValue386_OpNeq32F(v *Value) bool { return true } } -func rewriteValue386_OpNeq64F(v *Value) bool { +func rewriteValue386_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -15903,7 +15959,7 @@ func rewriteValue386_OpNeq64F(v *Value) bool { return true } } -func rewriteValue386_OpNeq8(v *Value) bool { +func rewriteValue386_OpNeq8_0(v *Value) bool { b := v.Block _ = b // match: (Neq8 x y) @@ -15920,7 +15976,7 @@ func rewriteValue386_OpNeq8(v *Value) bool { return true } } -func rewriteValue386_OpNeqB(v *Value) bool { +func rewriteValue386_OpNeqB_0(v *Value) bool { b := v.Block _ = b // match: (NeqB x y) @@ -15937,7 +15993,7 @@ func rewriteValue386_OpNeqB(v *Value) bool { return true } } -func rewriteValue386_OpNeqPtr(v *Value) bool { +func rewriteValue386_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -15954,7 +16010,7 @@ func rewriteValue386_OpNeqPtr(v *Value) bool { return true } } -func rewriteValue386_OpNilCheck(v *Value) bool { +func rewriteValue386_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -15967,7 +16023,7 @@ func rewriteValue386_OpNilCheck(v *Value) bool { return true } } -func rewriteValue386_OpNot(v *Value) bool { +func rewriteValue386_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORLconst [1] x) @@ -15979,7 +16035,7 @@ func rewriteValue386_OpNot(v *Value) bool { return true } } -func rewriteValue386_OpOffPtr(v *Value) bool { +func rewriteValue386_OpOffPtr_0(v *Value) bool { // match: (OffPtr [off] ptr) // cond: // result: (ADDLconst [off] ptr) @@ -15992,7 +16048,7 @@ func rewriteValue386_OpOffPtr(v *Value) bool { return true } } -func rewriteValue386_OpOr16(v *Value) bool { +func rewriteValue386_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORL x y) @@ -16005,7 +16061,7 @@ func rewriteValue386_OpOr16(v *Value) bool { return true } } -func rewriteValue386_OpOr32(v *Value) bool { +func rewriteValue386_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORL x y) @@ -16018,7 +16074,7 @@ func rewriteValue386_OpOr32(v *Value) bool { return true } } -func rewriteValue386_OpOr8(v *Value) bool { +func rewriteValue386_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORL x y) @@ -16031,7 +16087,7 @@ func rewriteValue386_OpOr8(v *Value) bool { return true } } -func rewriteValue386_OpOrB(v *Value) bool { +func rewriteValue386_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (ORL x y) @@ -16044,7 +16100,7 @@ func rewriteValue386_OpOrB(v *Value) bool { return true } } -func rewriteValue386_OpRound32F(v *Value) bool { +func rewriteValue386_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -16056,7 +16112,7 @@ func rewriteValue386_OpRound32F(v *Value) bool { return true } } -func rewriteValue386_OpRound64F(v *Value) bool { +func rewriteValue386_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -16068,7 +16124,7 @@ func rewriteValue386_OpRound64F(v *Value) bool { return true } } -func rewriteValue386_OpRsh16Ux16(v *Value) bool { +func rewriteValue386_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 x y) @@ -16092,7 +16148,7 @@ func rewriteValue386_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValue386_OpRsh16Ux32(v *Value) bool { +func rewriteValue386_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 x y) @@ -16116,7 +16172,7 @@ func rewriteValue386_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValue386_OpRsh16Ux64(v *Value) bool { +func rewriteValue386_OpRsh16Ux64_0(v *Value) bool { // match: (Rsh16Ux64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SHRWconst x [c]) @@ -16153,7 +16209,7 @@ func rewriteValue386_OpRsh16Ux64(v *Value) bool { } return false } -func rewriteValue386_OpRsh16Ux8(v *Value) bool { +func rewriteValue386_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 x y) @@ -16177,7 +16233,7 @@ func rewriteValue386_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValue386_OpRsh16x16(v *Value) bool { +func rewriteValue386_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 x y) @@ -16204,7 +16260,7 @@ func rewriteValue386_OpRsh16x16(v *Value) bool { return true } } -func rewriteValue386_OpRsh16x32(v *Value) bool { +func rewriteValue386_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 x y) @@ -16231,7 +16287,7 @@ func rewriteValue386_OpRsh16x32(v *Value) bool { return true } } -func rewriteValue386_OpRsh16x64(v *Value) bool { +func rewriteValue386_OpRsh16x64_0(v *Value) bool { // match: (Rsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SARWconst x [c]) @@ -16270,7 +16326,7 @@ func rewriteValue386_OpRsh16x64(v *Value) bool { } return false } -func rewriteValue386_OpRsh16x8(v *Value) bool { +func rewriteValue386_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 x y) @@ -16297,7 +16353,7 @@ func rewriteValue386_OpRsh16x8(v *Value) bool { return true } } -func rewriteValue386_OpRsh32Ux16(v *Value) bool { +func rewriteValue386_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 x y) @@ -16321,7 +16377,7 @@ func rewriteValue386_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValue386_OpRsh32Ux32(v *Value) bool { +func rewriteValue386_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x y) @@ -16345,7 +16401,7 @@ func rewriteValue386_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValue386_OpRsh32Ux64(v *Value) bool { +func rewriteValue386_OpRsh32Ux64_0(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SHRLconst x [c]) @@ -16382,7 +16438,7 @@ func rewriteValue386_OpRsh32Ux64(v *Value) bool { } return false } -func rewriteValue386_OpRsh32Ux8(v *Value) bool { +func rewriteValue386_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 x y) @@ -16406,7 +16462,7 @@ func rewriteValue386_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValue386_OpRsh32x16(v *Value) bool { +func rewriteValue386_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 x y) @@ -16433,7 +16489,7 @@ func rewriteValue386_OpRsh32x16(v *Value) bool { return true } } -func rewriteValue386_OpRsh32x32(v *Value) bool { +func rewriteValue386_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x y) @@ -16460,7 +16516,7 @@ func rewriteValue386_OpRsh32x32(v *Value) bool { return true } } -func rewriteValue386_OpRsh32x64(v *Value) bool { +func rewriteValue386_OpRsh32x64_0(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SARLconst x [c]) @@ -16499,7 +16555,7 @@ func rewriteValue386_OpRsh32x64(v *Value) bool { } return false } -func rewriteValue386_OpRsh32x8(v *Value) bool { +func rewriteValue386_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 x y) @@ -16526,7 +16582,7 @@ func rewriteValue386_OpRsh32x8(v *Value) bool { return true } } -func rewriteValue386_OpRsh8Ux16(v *Value) bool { +func rewriteValue386_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 x y) @@ -16550,7 +16606,7 @@ func rewriteValue386_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValue386_OpRsh8Ux32(v *Value) bool { +func rewriteValue386_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 x y) @@ -16574,7 +16630,7 @@ func rewriteValue386_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValue386_OpRsh8Ux64(v *Value) bool { +func rewriteValue386_OpRsh8Ux64_0(v *Value) bool { // match: (Rsh8Ux64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SHRBconst x [c]) @@ -16611,7 +16667,7 @@ func rewriteValue386_OpRsh8Ux64(v *Value) bool { } return false } -func rewriteValue386_OpRsh8Ux8(v *Value) bool { +func rewriteValue386_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 x y) @@ -16635,7 +16691,7 @@ func rewriteValue386_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValue386_OpRsh8x16(v *Value) bool { +func rewriteValue386_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 x y) @@ -16662,7 +16718,7 @@ func rewriteValue386_OpRsh8x16(v *Value) bool { return true } } -func rewriteValue386_OpRsh8x32(v *Value) bool { +func rewriteValue386_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 x y) @@ -16689,7 +16745,7 @@ func rewriteValue386_OpRsh8x32(v *Value) bool { return true } } -func rewriteValue386_OpRsh8x64(v *Value) bool { +func rewriteValue386_OpRsh8x64_0(v *Value) bool { // match: (Rsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SARBconst x [c]) @@ -16728,7 +16784,7 @@ func rewriteValue386_OpRsh8x64(v *Value) bool { } return false } -func rewriteValue386_OpRsh8x8(v *Value) bool { +func rewriteValue386_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 x y) @@ -16755,7 +16811,7 @@ func rewriteValue386_OpRsh8x8(v *Value) bool { return true } } -func rewriteValue386_OpSignExt16to32(v *Value) bool { +func rewriteValue386_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVWLSX x) @@ -16766,7 +16822,7 @@ func rewriteValue386_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValue386_OpSignExt8to16(v *Value) bool { +func rewriteValue386_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBLSX x) @@ -16777,7 +16833,7 @@ func rewriteValue386_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValue386_OpSignExt8to32(v *Value) bool { +func rewriteValue386_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBLSX x) @@ -16788,7 +16844,7 @@ func rewriteValue386_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValue386_OpSignmask(v *Value) bool { +func rewriteValue386_OpSignmask_0(v *Value) bool { // match: (Signmask x) // cond: // result: (SARLconst x [31]) @@ -16800,7 +16856,7 @@ func rewriteValue386_OpSignmask(v *Value) bool { return true } } -func rewriteValue386_OpSlicemask(v *Value) bool { +func rewriteValue386_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -16817,7 +16873,7 @@ func rewriteValue386_OpSlicemask(v *Value) bool { return true } } -func rewriteValue386_OpSqrt(v *Value) bool { +func rewriteValue386_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTSD x) @@ -16828,7 +16884,7 @@ func rewriteValue386_OpSqrt(v *Value) bool { return true } } -func rewriteValue386_OpStaticCall(v *Value) bool { +func rewriteValue386_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -16843,7 +16899,7 @@ func rewriteValue386_OpStaticCall(v *Value) bool { return true } } -func rewriteValue386_OpStore(v *Value) bool { +func rewriteValue386_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (MOVSDstore ptr val mem) @@ -16931,7 +16987,7 @@ func rewriteValue386_OpStore(v *Value) bool { } return false } -func rewriteValue386_OpSub16(v *Value) bool { +func rewriteValue386_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBL x y) @@ -16944,7 +17000,7 @@ func rewriteValue386_OpSub16(v *Value) bool { return true } } -func rewriteValue386_OpSub32(v *Value) bool { +func rewriteValue386_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBL x y) @@ -16957,7 +17013,7 @@ func rewriteValue386_OpSub32(v *Value) bool { return true } } -func rewriteValue386_OpSub32F(v *Value) bool { +func rewriteValue386_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBSS x y) @@ -16970,7 +17026,7 @@ func rewriteValue386_OpSub32F(v *Value) bool { return true } } -func rewriteValue386_OpSub32carry(v *Value) bool { +func rewriteValue386_OpSub32carry_0(v *Value) bool { // match: (Sub32carry x y) // cond: // result: (SUBLcarry x y) @@ -16983,7 +17039,7 @@ func rewriteValue386_OpSub32carry(v *Value) bool { return true } } -func rewriteValue386_OpSub32withcarry(v *Value) bool { +func rewriteValue386_OpSub32withcarry_0(v *Value) bool { // match: (Sub32withcarry x y c) // cond: // result: (SBBL x y c) @@ -16998,7 +17054,7 @@ func rewriteValue386_OpSub32withcarry(v *Value) bool { return true } } -func rewriteValue386_OpSub64F(v *Value) bool { +func rewriteValue386_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBSD x y) @@ -17011,7 +17067,7 @@ func rewriteValue386_OpSub64F(v *Value) bool { return true } } -func rewriteValue386_OpSub8(v *Value) bool { +func rewriteValue386_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBL x y) @@ -17024,7 +17080,7 @@ func rewriteValue386_OpSub8(v *Value) bool { return true } } -func rewriteValue386_OpSubPtr(v *Value) bool { +func rewriteValue386_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUBL x y) @@ -17037,7 +17093,7 @@ func rewriteValue386_OpSubPtr(v *Value) bool { return true } } -func rewriteValue386_OpTrunc16to8(v *Value) bool { +func rewriteValue386_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -17049,7 +17105,7 @@ func rewriteValue386_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValue386_OpTrunc32to16(v *Value) bool { +func rewriteValue386_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -17061,7 +17117,7 @@ func rewriteValue386_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValue386_OpTrunc32to8(v *Value) bool { +func rewriteValue386_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -17073,7 +17129,7 @@ func rewriteValue386_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValue386_OpXor16(v *Value) bool { +func rewriteValue386_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORL x y) @@ -17086,7 +17142,7 @@ func rewriteValue386_OpXor16(v *Value) bool { return true } } -func rewriteValue386_OpXor32(v *Value) bool { +func rewriteValue386_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORL x y) @@ -17099,7 +17155,7 @@ func rewriteValue386_OpXor32(v *Value) bool { return true } } -func rewriteValue386_OpXor8(v *Value) bool { +func rewriteValue386_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORL x y) @@ -17112,11 +17168,9 @@ func rewriteValue386_OpXor8(v *Value) bool { return true } } -func rewriteValue386_OpZero(v *Value) bool { +func rewriteValue386_OpZero_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Zero [0] _ mem) @@ -17295,6 +17349,15 @@ func rewriteValue386_OpZero(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValue386_OpZero_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Zero [12] destptr mem) // cond: // result: (MOVLstoreconst [makeValAndOff(0,8)] destptr (MOVLstoreconst [makeValAndOff(0,4)] destptr (MOVLstoreconst [0] destptr mem))) @@ -17387,7 +17450,7 @@ func rewriteValue386_OpZero(v *Value) bool { } return false } -func rewriteValue386_OpZeroExt16to32(v *Value) bool { +func rewriteValue386_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVWLZX x) @@ -17398,7 +17461,7 @@ func rewriteValue386_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValue386_OpZeroExt8to16(v *Value) bool { +func rewriteValue386_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBLZX x) @@ -17409,7 +17472,7 @@ func rewriteValue386_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValue386_OpZeroExt8to32(v *Value) bool { +func rewriteValue386_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBLZX x) @@ -17420,7 +17483,7 @@ func rewriteValue386_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValue386_OpZeromask(v *Value) bool { +func rewriteValue386_OpZeromask_0(v *Value) bool { b := v.Block _ = b // match: (Zeromask x) diff --git a/src/cmd/compile/internal/ssa/rewriteAMD64.go b/src/cmd/compile/internal/ssa/rewriteAMD64.go index 9f9fe3b111..4bd2a795fa 100644 --- a/src/cmd/compile/internal/ssa/rewriteAMD64.go +++ b/src/cmd/compile/internal/ssa/rewriteAMD64.go @@ -14,849 +14,849 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueAMD64(v *Value) bool { switch v.Op { case OpAMD64ADDL: - return rewriteValueAMD64_OpAMD64ADDL(v) + return rewriteValueAMD64_OpAMD64ADDL_0(v) || rewriteValueAMD64_OpAMD64ADDL_10(v) case OpAMD64ADDLconst: - return rewriteValueAMD64_OpAMD64ADDLconst(v) + return rewriteValueAMD64_OpAMD64ADDLconst_0(v) case OpAMD64ADDQ: - return rewriteValueAMD64_OpAMD64ADDQ(v) + return rewriteValueAMD64_OpAMD64ADDQ_0(v) || rewriteValueAMD64_OpAMD64ADDQ_10(v) || rewriteValueAMD64_OpAMD64ADDQ_20(v) case OpAMD64ADDQconst: - return rewriteValueAMD64_OpAMD64ADDQconst(v) + return rewriteValueAMD64_OpAMD64ADDQconst_0(v) case OpAMD64ADDSD: - return rewriteValueAMD64_OpAMD64ADDSD(v) + return rewriteValueAMD64_OpAMD64ADDSD_0(v) case OpAMD64ADDSS: - return rewriteValueAMD64_OpAMD64ADDSS(v) + return rewriteValueAMD64_OpAMD64ADDSS_0(v) case OpAMD64ANDL: - return rewriteValueAMD64_OpAMD64ANDL(v) + return rewriteValueAMD64_OpAMD64ANDL_0(v) case OpAMD64ANDLconst: - return rewriteValueAMD64_OpAMD64ANDLconst(v) + return rewriteValueAMD64_OpAMD64ANDLconst_0(v) case OpAMD64ANDQ: - return rewriteValueAMD64_OpAMD64ANDQ(v) + return rewriteValueAMD64_OpAMD64ANDQ_0(v) case OpAMD64ANDQconst: - return rewriteValueAMD64_OpAMD64ANDQconst(v) + return rewriteValueAMD64_OpAMD64ANDQconst_0(v) case OpAMD64BSFQ: - return rewriteValueAMD64_OpAMD64BSFQ(v) + return rewriteValueAMD64_OpAMD64BSFQ_0(v) case OpAMD64BTQconst: - return rewriteValueAMD64_OpAMD64BTQconst(v) + return rewriteValueAMD64_OpAMD64BTQconst_0(v) case OpAMD64CMOVQEQ: - return rewriteValueAMD64_OpAMD64CMOVQEQ(v) + return rewriteValueAMD64_OpAMD64CMOVQEQ_0(v) case OpAMD64CMPB: - return rewriteValueAMD64_OpAMD64CMPB(v) + return rewriteValueAMD64_OpAMD64CMPB_0(v) case OpAMD64CMPBconst: - return rewriteValueAMD64_OpAMD64CMPBconst(v) + return rewriteValueAMD64_OpAMD64CMPBconst_0(v) case OpAMD64CMPL: - return rewriteValueAMD64_OpAMD64CMPL(v) + return rewriteValueAMD64_OpAMD64CMPL_0(v) case OpAMD64CMPLconst: - return rewriteValueAMD64_OpAMD64CMPLconst(v) + return rewriteValueAMD64_OpAMD64CMPLconst_0(v) case OpAMD64CMPQ: - return rewriteValueAMD64_OpAMD64CMPQ(v) + return rewriteValueAMD64_OpAMD64CMPQ_0(v) case OpAMD64CMPQconst: - return rewriteValueAMD64_OpAMD64CMPQconst(v) + return rewriteValueAMD64_OpAMD64CMPQconst_0(v) || rewriteValueAMD64_OpAMD64CMPQconst_10(v) case OpAMD64CMPW: - return rewriteValueAMD64_OpAMD64CMPW(v) + return rewriteValueAMD64_OpAMD64CMPW_0(v) case OpAMD64CMPWconst: - return rewriteValueAMD64_OpAMD64CMPWconst(v) + return rewriteValueAMD64_OpAMD64CMPWconst_0(v) case OpAMD64CMPXCHGLlock: - return rewriteValueAMD64_OpAMD64CMPXCHGLlock(v) + return rewriteValueAMD64_OpAMD64CMPXCHGLlock_0(v) case OpAMD64CMPXCHGQlock: - return rewriteValueAMD64_OpAMD64CMPXCHGQlock(v) + return rewriteValueAMD64_OpAMD64CMPXCHGQlock_0(v) case OpAMD64LEAL: - return rewriteValueAMD64_OpAMD64LEAL(v) + return rewriteValueAMD64_OpAMD64LEAL_0(v) case OpAMD64LEAQ: - return rewriteValueAMD64_OpAMD64LEAQ(v) + return rewriteValueAMD64_OpAMD64LEAQ_0(v) case OpAMD64LEAQ1: - return rewriteValueAMD64_OpAMD64LEAQ1(v) + return rewriteValueAMD64_OpAMD64LEAQ1_0(v) case OpAMD64LEAQ2: - return rewriteValueAMD64_OpAMD64LEAQ2(v) + return rewriteValueAMD64_OpAMD64LEAQ2_0(v) case OpAMD64LEAQ4: - return rewriteValueAMD64_OpAMD64LEAQ4(v) + return rewriteValueAMD64_OpAMD64LEAQ4_0(v) case OpAMD64LEAQ8: - return rewriteValueAMD64_OpAMD64LEAQ8(v) + return rewriteValueAMD64_OpAMD64LEAQ8_0(v) case OpAMD64MOVBQSX: - return rewriteValueAMD64_OpAMD64MOVBQSX(v) + return rewriteValueAMD64_OpAMD64MOVBQSX_0(v) case OpAMD64MOVBQSXload: - return rewriteValueAMD64_OpAMD64MOVBQSXload(v) + return rewriteValueAMD64_OpAMD64MOVBQSXload_0(v) case OpAMD64MOVBQZX: - return rewriteValueAMD64_OpAMD64MOVBQZX(v) + return rewriteValueAMD64_OpAMD64MOVBQZX_0(v) case OpAMD64MOVBload: - return rewriteValueAMD64_OpAMD64MOVBload(v) + return rewriteValueAMD64_OpAMD64MOVBload_0(v) case OpAMD64MOVBloadidx1: - return rewriteValueAMD64_OpAMD64MOVBloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVBloadidx1_0(v) case OpAMD64MOVBstore: - return rewriteValueAMD64_OpAMD64MOVBstore(v) + return rewriteValueAMD64_OpAMD64MOVBstore_0(v) || rewriteValueAMD64_OpAMD64MOVBstore_10(v) case OpAMD64MOVBstoreconst: - return rewriteValueAMD64_OpAMD64MOVBstoreconst(v) + return rewriteValueAMD64_OpAMD64MOVBstoreconst_0(v) case OpAMD64MOVBstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1(v) + return rewriteValueAMD64_OpAMD64MOVBstoreconstidx1_0(v) case OpAMD64MOVBstoreidx1: - return rewriteValueAMD64_OpAMD64MOVBstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVBstoreidx1_0(v) case OpAMD64MOVLQSX: - return rewriteValueAMD64_OpAMD64MOVLQSX(v) + return rewriteValueAMD64_OpAMD64MOVLQSX_0(v) case OpAMD64MOVLQSXload: - return rewriteValueAMD64_OpAMD64MOVLQSXload(v) + return rewriteValueAMD64_OpAMD64MOVLQSXload_0(v) case OpAMD64MOVLQZX: - return rewriteValueAMD64_OpAMD64MOVLQZX(v) + return rewriteValueAMD64_OpAMD64MOVLQZX_0(v) case OpAMD64MOVLatomicload: - return rewriteValueAMD64_OpAMD64MOVLatomicload(v) + return rewriteValueAMD64_OpAMD64MOVLatomicload_0(v) case OpAMD64MOVLload: - return rewriteValueAMD64_OpAMD64MOVLload(v) + return rewriteValueAMD64_OpAMD64MOVLload_0(v) case OpAMD64MOVLloadidx1: - return rewriteValueAMD64_OpAMD64MOVLloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVLloadidx1_0(v) case OpAMD64MOVLloadidx4: - return rewriteValueAMD64_OpAMD64MOVLloadidx4(v) + return rewriteValueAMD64_OpAMD64MOVLloadidx4_0(v) case OpAMD64MOVLstore: - return rewriteValueAMD64_OpAMD64MOVLstore(v) + return rewriteValueAMD64_OpAMD64MOVLstore_0(v) || rewriteValueAMD64_OpAMD64MOVLstore_10(v) case OpAMD64MOVLstoreconst: - return rewriteValueAMD64_OpAMD64MOVLstoreconst(v) + return rewriteValueAMD64_OpAMD64MOVLstoreconst_0(v) case OpAMD64MOVLstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1(v) + return rewriteValueAMD64_OpAMD64MOVLstoreconstidx1_0(v) case OpAMD64MOVLstoreconstidx4: - return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4(v) + return rewriteValueAMD64_OpAMD64MOVLstoreconstidx4_0(v) case OpAMD64MOVLstoreidx1: - return rewriteValueAMD64_OpAMD64MOVLstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVLstoreidx1_0(v) case OpAMD64MOVLstoreidx4: - return rewriteValueAMD64_OpAMD64MOVLstoreidx4(v) + return rewriteValueAMD64_OpAMD64MOVLstoreidx4_0(v) case OpAMD64MOVOload: - return rewriteValueAMD64_OpAMD64MOVOload(v) + return rewriteValueAMD64_OpAMD64MOVOload_0(v) case OpAMD64MOVOstore: - return rewriteValueAMD64_OpAMD64MOVOstore(v) + return rewriteValueAMD64_OpAMD64MOVOstore_0(v) case OpAMD64MOVQatomicload: - return rewriteValueAMD64_OpAMD64MOVQatomicload(v) + return rewriteValueAMD64_OpAMD64MOVQatomicload_0(v) case OpAMD64MOVQload: - return rewriteValueAMD64_OpAMD64MOVQload(v) + return rewriteValueAMD64_OpAMD64MOVQload_0(v) case OpAMD64MOVQloadidx1: - return rewriteValueAMD64_OpAMD64MOVQloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVQloadidx1_0(v) case OpAMD64MOVQloadidx8: - return rewriteValueAMD64_OpAMD64MOVQloadidx8(v) + return rewriteValueAMD64_OpAMD64MOVQloadidx8_0(v) case OpAMD64MOVQstore: - return rewriteValueAMD64_OpAMD64MOVQstore(v) + return rewriteValueAMD64_OpAMD64MOVQstore_0(v) case OpAMD64MOVQstoreconst: - return rewriteValueAMD64_OpAMD64MOVQstoreconst(v) + return rewriteValueAMD64_OpAMD64MOVQstoreconst_0(v) case OpAMD64MOVQstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1(v) + return rewriteValueAMD64_OpAMD64MOVQstoreconstidx1_0(v) case OpAMD64MOVQstoreconstidx8: - return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8(v) + return rewriteValueAMD64_OpAMD64MOVQstoreconstidx8_0(v) case OpAMD64MOVQstoreidx1: - return rewriteValueAMD64_OpAMD64MOVQstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVQstoreidx1_0(v) case OpAMD64MOVQstoreidx8: - return rewriteValueAMD64_OpAMD64MOVQstoreidx8(v) + return rewriteValueAMD64_OpAMD64MOVQstoreidx8_0(v) case OpAMD64MOVSDload: - return rewriteValueAMD64_OpAMD64MOVSDload(v) + return rewriteValueAMD64_OpAMD64MOVSDload_0(v) case OpAMD64MOVSDloadidx1: - return rewriteValueAMD64_OpAMD64MOVSDloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVSDloadidx1_0(v) case OpAMD64MOVSDloadidx8: - return rewriteValueAMD64_OpAMD64MOVSDloadidx8(v) + return rewriteValueAMD64_OpAMD64MOVSDloadidx8_0(v) case OpAMD64MOVSDstore: - return rewriteValueAMD64_OpAMD64MOVSDstore(v) + return rewriteValueAMD64_OpAMD64MOVSDstore_0(v) case OpAMD64MOVSDstoreidx1: - return rewriteValueAMD64_OpAMD64MOVSDstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVSDstoreidx1_0(v) case OpAMD64MOVSDstoreidx8: - return rewriteValueAMD64_OpAMD64MOVSDstoreidx8(v) + return rewriteValueAMD64_OpAMD64MOVSDstoreidx8_0(v) case OpAMD64MOVSSload: - return rewriteValueAMD64_OpAMD64MOVSSload(v) + return rewriteValueAMD64_OpAMD64MOVSSload_0(v) case OpAMD64MOVSSloadidx1: - return rewriteValueAMD64_OpAMD64MOVSSloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVSSloadidx1_0(v) case OpAMD64MOVSSloadidx4: - return rewriteValueAMD64_OpAMD64MOVSSloadidx4(v) + return rewriteValueAMD64_OpAMD64MOVSSloadidx4_0(v) case OpAMD64MOVSSstore: - return rewriteValueAMD64_OpAMD64MOVSSstore(v) + return rewriteValueAMD64_OpAMD64MOVSSstore_0(v) case OpAMD64MOVSSstoreidx1: - return rewriteValueAMD64_OpAMD64MOVSSstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVSSstoreidx1_0(v) case OpAMD64MOVSSstoreidx4: - return rewriteValueAMD64_OpAMD64MOVSSstoreidx4(v) + return rewriteValueAMD64_OpAMD64MOVSSstoreidx4_0(v) case OpAMD64MOVWQSX: - return rewriteValueAMD64_OpAMD64MOVWQSX(v) + return rewriteValueAMD64_OpAMD64MOVWQSX_0(v) case OpAMD64MOVWQSXload: - return rewriteValueAMD64_OpAMD64MOVWQSXload(v) + return rewriteValueAMD64_OpAMD64MOVWQSXload_0(v) case OpAMD64MOVWQZX: - return rewriteValueAMD64_OpAMD64MOVWQZX(v) + return rewriteValueAMD64_OpAMD64MOVWQZX_0(v) case OpAMD64MOVWload: - return rewriteValueAMD64_OpAMD64MOVWload(v) + return rewriteValueAMD64_OpAMD64MOVWload_0(v) case OpAMD64MOVWloadidx1: - return rewriteValueAMD64_OpAMD64MOVWloadidx1(v) + return rewriteValueAMD64_OpAMD64MOVWloadidx1_0(v) case OpAMD64MOVWloadidx2: - return rewriteValueAMD64_OpAMD64MOVWloadidx2(v) + return rewriteValueAMD64_OpAMD64MOVWloadidx2_0(v) case OpAMD64MOVWstore: - return rewriteValueAMD64_OpAMD64MOVWstore(v) + return rewriteValueAMD64_OpAMD64MOVWstore_0(v) || rewriteValueAMD64_OpAMD64MOVWstore_10(v) case OpAMD64MOVWstoreconst: - return rewriteValueAMD64_OpAMD64MOVWstoreconst(v) + return rewriteValueAMD64_OpAMD64MOVWstoreconst_0(v) case OpAMD64MOVWstoreconstidx1: - return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1(v) + return rewriteValueAMD64_OpAMD64MOVWstoreconstidx1_0(v) case OpAMD64MOVWstoreconstidx2: - return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2(v) + return rewriteValueAMD64_OpAMD64MOVWstoreconstidx2_0(v) case OpAMD64MOVWstoreidx1: - return rewriteValueAMD64_OpAMD64MOVWstoreidx1(v) + return rewriteValueAMD64_OpAMD64MOVWstoreidx1_0(v) case OpAMD64MOVWstoreidx2: - return rewriteValueAMD64_OpAMD64MOVWstoreidx2(v) + return rewriteValueAMD64_OpAMD64MOVWstoreidx2_0(v) case OpAMD64MULL: - return rewriteValueAMD64_OpAMD64MULL(v) + return rewriteValueAMD64_OpAMD64MULL_0(v) case OpAMD64MULLconst: - return rewriteValueAMD64_OpAMD64MULLconst(v) + return rewriteValueAMD64_OpAMD64MULLconst_0(v) case OpAMD64MULQ: - return rewriteValueAMD64_OpAMD64MULQ(v) + return rewriteValueAMD64_OpAMD64MULQ_0(v) case OpAMD64MULQconst: - return rewriteValueAMD64_OpAMD64MULQconst(v) + return rewriteValueAMD64_OpAMD64MULQconst_0(v) || rewriteValueAMD64_OpAMD64MULQconst_10(v) || rewriteValueAMD64_OpAMD64MULQconst_20(v) case OpAMD64MULSD: - return rewriteValueAMD64_OpAMD64MULSD(v) + return rewriteValueAMD64_OpAMD64MULSD_0(v) case OpAMD64MULSS: - return rewriteValueAMD64_OpAMD64MULSS(v) + return rewriteValueAMD64_OpAMD64MULSS_0(v) case OpAMD64NEGL: - return rewriteValueAMD64_OpAMD64NEGL(v) + return rewriteValueAMD64_OpAMD64NEGL_0(v) case OpAMD64NEGQ: - return rewriteValueAMD64_OpAMD64NEGQ(v) + return rewriteValueAMD64_OpAMD64NEGQ_0(v) case OpAMD64NOTL: - return rewriteValueAMD64_OpAMD64NOTL(v) + return rewriteValueAMD64_OpAMD64NOTL_0(v) case OpAMD64NOTQ: - return rewriteValueAMD64_OpAMD64NOTQ(v) + return rewriteValueAMD64_OpAMD64NOTQ_0(v) case OpAMD64ORL: - return rewriteValueAMD64_OpAMD64ORL(v) + return rewriteValueAMD64_OpAMD64ORL_0(v) || rewriteValueAMD64_OpAMD64ORL_10(v) || rewriteValueAMD64_OpAMD64ORL_20(v) || rewriteValueAMD64_OpAMD64ORL_30(v) || rewriteValueAMD64_OpAMD64ORL_40(v) || rewriteValueAMD64_OpAMD64ORL_50(v) || rewriteValueAMD64_OpAMD64ORL_60(v) || rewriteValueAMD64_OpAMD64ORL_70(v) || rewriteValueAMD64_OpAMD64ORL_80(v) || rewriteValueAMD64_OpAMD64ORL_90(v) || rewriteValueAMD64_OpAMD64ORL_100(v) || rewriteValueAMD64_OpAMD64ORL_110(v) || rewriteValueAMD64_OpAMD64ORL_120(v) || rewriteValueAMD64_OpAMD64ORL_130(v) case OpAMD64ORLconst: - return rewriteValueAMD64_OpAMD64ORLconst(v) + return rewriteValueAMD64_OpAMD64ORLconst_0(v) case OpAMD64ORQ: - return rewriteValueAMD64_OpAMD64ORQ(v) + return rewriteValueAMD64_OpAMD64ORQ_0(v) || rewriteValueAMD64_OpAMD64ORQ_10(v) || rewriteValueAMD64_OpAMD64ORQ_20(v) || rewriteValueAMD64_OpAMD64ORQ_30(v) || rewriteValueAMD64_OpAMD64ORQ_40(v) || rewriteValueAMD64_OpAMD64ORQ_50(v) || rewriteValueAMD64_OpAMD64ORQ_60(v) || rewriteValueAMD64_OpAMD64ORQ_70(v) || rewriteValueAMD64_OpAMD64ORQ_80(v) || rewriteValueAMD64_OpAMD64ORQ_90(v) || rewriteValueAMD64_OpAMD64ORQ_100(v) || rewriteValueAMD64_OpAMD64ORQ_110(v) || rewriteValueAMD64_OpAMD64ORQ_120(v) || rewriteValueAMD64_OpAMD64ORQ_130(v) || rewriteValueAMD64_OpAMD64ORQ_140(v) || rewriteValueAMD64_OpAMD64ORQ_150(v) || rewriteValueAMD64_OpAMD64ORQ_160(v) case OpAMD64ORQconst: - return rewriteValueAMD64_OpAMD64ORQconst(v) + return rewriteValueAMD64_OpAMD64ORQconst_0(v) case OpAMD64ROLB: - return rewriteValueAMD64_OpAMD64ROLB(v) + return rewriteValueAMD64_OpAMD64ROLB_0(v) case OpAMD64ROLBconst: - return rewriteValueAMD64_OpAMD64ROLBconst(v) + return rewriteValueAMD64_OpAMD64ROLBconst_0(v) case OpAMD64ROLL: - return rewriteValueAMD64_OpAMD64ROLL(v) + return rewriteValueAMD64_OpAMD64ROLL_0(v) case OpAMD64ROLLconst: - return rewriteValueAMD64_OpAMD64ROLLconst(v) + return rewriteValueAMD64_OpAMD64ROLLconst_0(v) case OpAMD64ROLQ: - return rewriteValueAMD64_OpAMD64ROLQ(v) + return rewriteValueAMD64_OpAMD64ROLQ_0(v) case OpAMD64ROLQconst: - return rewriteValueAMD64_OpAMD64ROLQconst(v) + return rewriteValueAMD64_OpAMD64ROLQconst_0(v) case OpAMD64ROLW: - return rewriteValueAMD64_OpAMD64ROLW(v) + return rewriteValueAMD64_OpAMD64ROLW_0(v) case OpAMD64ROLWconst: - return rewriteValueAMD64_OpAMD64ROLWconst(v) + return rewriteValueAMD64_OpAMD64ROLWconst_0(v) case OpAMD64RORB: - return rewriteValueAMD64_OpAMD64RORB(v) + return rewriteValueAMD64_OpAMD64RORB_0(v) case OpAMD64RORL: - return rewriteValueAMD64_OpAMD64RORL(v) + return rewriteValueAMD64_OpAMD64RORL_0(v) case OpAMD64RORQ: - return rewriteValueAMD64_OpAMD64RORQ(v) + return rewriteValueAMD64_OpAMD64RORQ_0(v) case OpAMD64RORW: - return rewriteValueAMD64_OpAMD64RORW(v) + return rewriteValueAMD64_OpAMD64RORW_0(v) case OpAMD64SARB: - return rewriteValueAMD64_OpAMD64SARB(v) + return rewriteValueAMD64_OpAMD64SARB_0(v) case OpAMD64SARBconst: - return rewriteValueAMD64_OpAMD64SARBconst(v) + return rewriteValueAMD64_OpAMD64SARBconst_0(v) case OpAMD64SARL: - return rewriteValueAMD64_OpAMD64SARL(v) + return rewriteValueAMD64_OpAMD64SARL_0(v) case OpAMD64SARLconst: - return rewriteValueAMD64_OpAMD64SARLconst(v) + return rewriteValueAMD64_OpAMD64SARLconst_0(v) case OpAMD64SARQ: - return rewriteValueAMD64_OpAMD64SARQ(v) + return rewriteValueAMD64_OpAMD64SARQ_0(v) case OpAMD64SARQconst: - return rewriteValueAMD64_OpAMD64SARQconst(v) + return rewriteValueAMD64_OpAMD64SARQconst_0(v) case OpAMD64SARW: - return rewriteValueAMD64_OpAMD64SARW(v) + return rewriteValueAMD64_OpAMD64SARW_0(v) case OpAMD64SARWconst: - return rewriteValueAMD64_OpAMD64SARWconst(v) + return rewriteValueAMD64_OpAMD64SARWconst_0(v) case OpAMD64SBBLcarrymask: - return rewriteValueAMD64_OpAMD64SBBLcarrymask(v) + return rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v) case OpAMD64SBBQcarrymask: - return rewriteValueAMD64_OpAMD64SBBQcarrymask(v) + return rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v) case OpAMD64SETA: - return rewriteValueAMD64_OpAMD64SETA(v) + return rewriteValueAMD64_OpAMD64SETA_0(v) case OpAMD64SETAE: - return rewriteValueAMD64_OpAMD64SETAE(v) + return rewriteValueAMD64_OpAMD64SETAE_0(v) case OpAMD64SETB: - return rewriteValueAMD64_OpAMD64SETB(v) + return rewriteValueAMD64_OpAMD64SETB_0(v) case OpAMD64SETBE: - return rewriteValueAMD64_OpAMD64SETBE(v) + return rewriteValueAMD64_OpAMD64SETBE_0(v) case OpAMD64SETEQ: - return rewriteValueAMD64_OpAMD64SETEQ(v) + return rewriteValueAMD64_OpAMD64SETEQ_0(v) || rewriteValueAMD64_OpAMD64SETEQ_10(v) case OpAMD64SETG: - return rewriteValueAMD64_OpAMD64SETG(v) + return rewriteValueAMD64_OpAMD64SETG_0(v) case OpAMD64SETGE: - return rewriteValueAMD64_OpAMD64SETGE(v) + return rewriteValueAMD64_OpAMD64SETGE_0(v) case OpAMD64SETL: - return rewriteValueAMD64_OpAMD64SETL(v) + return rewriteValueAMD64_OpAMD64SETL_0(v) case OpAMD64SETLE: - return rewriteValueAMD64_OpAMD64SETLE(v) + return rewriteValueAMD64_OpAMD64SETLE_0(v) case OpAMD64SETNE: - return rewriteValueAMD64_OpAMD64SETNE(v) + return rewriteValueAMD64_OpAMD64SETNE_0(v) || rewriteValueAMD64_OpAMD64SETNE_10(v) case OpAMD64SHLL: - return rewriteValueAMD64_OpAMD64SHLL(v) + return rewriteValueAMD64_OpAMD64SHLL_0(v) case OpAMD64SHLLconst: - return rewriteValueAMD64_OpAMD64SHLLconst(v) + return rewriteValueAMD64_OpAMD64SHLLconst_0(v) case OpAMD64SHLQ: - return rewriteValueAMD64_OpAMD64SHLQ(v) + return rewriteValueAMD64_OpAMD64SHLQ_0(v) case OpAMD64SHLQconst: - return rewriteValueAMD64_OpAMD64SHLQconst(v) + return rewriteValueAMD64_OpAMD64SHLQconst_0(v) case OpAMD64SHRB: - return rewriteValueAMD64_OpAMD64SHRB(v) + return rewriteValueAMD64_OpAMD64SHRB_0(v) case OpAMD64SHRBconst: - return rewriteValueAMD64_OpAMD64SHRBconst(v) + return rewriteValueAMD64_OpAMD64SHRBconst_0(v) case OpAMD64SHRL: - return rewriteValueAMD64_OpAMD64SHRL(v) + return rewriteValueAMD64_OpAMD64SHRL_0(v) case OpAMD64SHRLconst: - return rewriteValueAMD64_OpAMD64SHRLconst(v) + return rewriteValueAMD64_OpAMD64SHRLconst_0(v) case OpAMD64SHRQ: - return rewriteValueAMD64_OpAMD64SHRQ(v) + return rewriteValueAMD64_OpAMD64SHRQ_0(v) case OpAMD64SHRQconst: - return rewriteValueAMD64_OpAMD64SHRQconst(v) + return rewriteValueAMD64_OpAMD64SHRQconst_0(v) case OpAMD64SHRW: - return rewriteValueAMD64_OpAMD64SHRW(v) + return rewriteValueAMD64_OpAMD64SHRW_0(v) case OpAMD64SHRWconst: - return rewriteValueAMD64_OpAMD64SHRWconst(v) + return rewriteValueAMD64_OpAMD64SHRWconst_0(v) case OpAMD64SUBL: - return rewriteValueAMD64_OpAMD64SUBL(v) + return rewriteValueAMD64_OpAMD64SUBL_0(v) case OpAMD64SUBLconst: - return rewriteValueAMD64_OpAMD64SUBLconst(v) + return rewriteValueAMD64_OpAMD64SUBLconst_0(v) case OpAMD64SUBQ: - return rewriteValueAMD64_OpAMD64SUBQ(v) + return rewriteValueAMD64_OpAMD64SUBQ_0(v) case OpAMD64SUBQconst: - return rewriteValueAMD64_OpAMD64SUBQconst(v) + return rewriteValueAMD64_OpAMD64SUBQconst_0(v) case OpAMD64SUBSD: - return rewriteValueAMD64_OpAMD64SUBSD(v) + return rewriteValueAMD64_OpAMD64SUBSD_0(v) case OpAMD64SUBSS: - return rewriteValueAMD64_OpAMD64SUBSS(v) + return rewriteValueAMD64_OpAMD64SUBSS_0(v) case OpAMD64TESTB: - return rewriteValueAMD64_OpAMD64TESTB(v) + return rewriteValueAMD64_OpAMD64TESTB_0(v) case OpAMD64TESTL: - return rewriteValueAMD64_OpAMD64TESTL(v) + return rewriteValueAMD64_OpAMD64TESTL_0(v) case OpAMD64TESTQ: - return rewriteValueAMD64_OpAMD64TESTQ(v) + return rewriteValueAMD64_OpAMD64TESTQ_0(v) case OpAMD64TESTW: - return rewriteValueAMD64_OpAMD64TESTW(v) + return rewriteValueAMD64_OpAMD64TESTW_0(v) case OpAMD64XADDLlock: - return rewriteValueAMD64_OpAMD64XADDLlock(v) + return rewriteValueAMD64_OpAMD64XADDLlock_0(v) case OpAMD64XADDQlock: - return rewriteValueAMD64_OpAMD64XADDQlock(v) + return rewriteValueAMD64_OpAMD64XADDQlock_0(v) case OpAMD64XCHGL: - return rewriteValueAMD64_OpAMD64XCHGL(v) + return rewriteValueAMD64_OpAMD64XCHGL_0(v) case OpAMD64XCHGQ: - return rewriteValueAMD64_OpAMD64XCHGQ(v) + return rewriteValueAMD64_OpAMD64XCHGQ_0(v) case OpAMD64XORL: - return rewriteValueAMD64_OpAMD64XORL(v) + return rewriteValueAMD64_OpAMD64XORL_0(v) || rewriteValueAMD64_OpAMD64XORL_10(v) case OpAMD64XORLconst: - return rewriteValueAMD64_OpAMD64XORLconst(v) + return rewriteValueAMD64_OpAMD64XORLconst_0(v) case OpAMD64XORQ: - return rewriteValueAMD64_OpAMD64XORQ(v) + return rewriteValueAMD64_OpAMD64XORQ_0(v) case OpAMD64XORQconst: - return rewriteValueAMD64_OpAMD64XORQconst(v) + return rewriteValueAMD64_OpAMD64XORQconst_0(v) case OpAdd16: - return rewriteValueAMD64_OpAdd16(v) + return rewriteValueAMD64_OpAdd16_0(v) case OpAdd32: - return rewriteValueAMD64_OpAdd32(v) + return rewriteValueAMD64_OpAdd32_0(v) case OpAdd32F: - return rewriteValueAMD64_OpAdd32F(v) + return rewriteValueAMD64_OpAdd32F_0(v) case OpAdd64: - return rewriteValueAMD64_OpAdd64(v) + return rewriteValueAMD64_OpAdd64_0(v) case OpAdd64F: - return rewriteValueAMD64_OpAdd64F(v) + return rewriteValueAMD64_OpAdd64F_0(v) case OpAdd8: - return rewriteValueAMD64_OpAdd8(v) + return rewriteValueAMD64_OpAdd8_0(v) case OpAddPtr: - return rewriteValueAMD64_OpAddPtr(v) + return rewriteValueAMD64_OpAddPtr_0(v) case OpAddr: - return rewriteValueAMD64_OpAddr(v) + return rewriteValueAMD64_OpAddr_0(v) case OpAnd16: - return rewriteValueAMD64_OpAnd16(v) + return rewriteValueAMD64_OpAnd16_0(v) case OpAnd32: - return rewriteValueAMD64_OpAnd32(v) + return rewriteValueAMD64_OpAnd32_0(v) case OpAnd64: - return rewriteValueAMD64_OpAnd64(v) + return rewriteValueAMD64_OpAnd64_0(v) case OpAnd8: - return rewriteValueAMD64_OpAnd8(v) + return rewriteValueAMD64_OpAnd8_0(v) case OpAndB: - return rewriteValueAMD64_OpAndB(v) + return rewriteValueAMD64_OpAndB_0(v) case OpAtomicAdd32: - return rewriteValueAMD64_OpAtomicAdd32(v) + return rewriteValueAMD64_OpAtomicAdd32_0(v) case OpAtomicAdd64: - return rewriteValueAMD64_OpAtomicAdd64(v) + return rewriteValueAMD64_OpAtomicAdd64_0(v) case OpAtomicAnd8: - return rewriteValueAMD64_OpAtomicAnd8(v) + return rewriteValueAMD64_OpAtomicAnd8_0(v) case OpAtomicCompareAndSwap32: - return rewriteValueAMD64_OpAtomicCompareAndSwap32(v) + return rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v) case OpAtomicCompareAndSwap64: - return rewriteValueAMD64_OpAtomicCompareAndSwap64(v) + return rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v) case OpAtomicExchange32: - return rewriteValueAMD64_OpAtomicExchange32(v) + return rewriteValueAMD64_OpAtomicExchange32_0(v) case OpAtomicExchange64: - return rewriteValueAMD64_OpAtomicExchange64(v) + return rewriteValueAMD64_OpAtomicExchange64_0(v) case OpAtomicLoad32: - return rewriteValueAMD64_OpAtomicLoad32(v) + return rewriteValueAMD64_OpAtomicLoad32_0(v) case OpAtomicLoad64: - return rewriteValueAMD64_OpAtomicLoad64(v) + return rewriteValueAMD64_OpAtomicLoad64_0(v) case OpAtomicLoadPtr: - return rewriteValueAMD64_OpAtomicLoadPtr(v) + return rewriteValueAMD64_OpAtomicLoadPtr_0(v) case OpAtomicOr8: - return rewriteValueAMD64_OpAtomicOr8(v) + return rewriteValueAMD64_OpAtomicOr8_0(v) case OpAtomicStore32: - return rewriteValueAMD64_OpAtomicStore32(v) + return rewriteValueAMD64_OpAtomicStore32_0(v) case OpAtomicStore64: - return rewriteValueAMD64_OpAtomicStore64(v) + return rewriteValueAMD64_OpAtomicStore64_0(v) case OpAtomicStorePtrNoWB: - return rewriteValueAMD64_OpAtomicStorePtrNoWB(v) + return rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v) case OpAvg64u: - return rewriteValueAMD64_OpAvg64u(v) + return rewriteValueAMD64_OpAvg64u_0(v) case OpBitLen32: - return rewriteValueAMD64_OpBitLen32(v) + return rewriteValueAMD64_OpBitLen32_0(v) case OpBitLen64: - return rewriteValueAMD64_OpBitLen64(v) + return rewriteValueAMD64_OpBitLen64_0(v) case OpBswap32: - return rewriteValueAMD64_OpBswap32(v) + return rewriteValueAMD64_OpBswap32_0(v) case OpBswap64: - return rewriteValueAMD64_OpBswap64(v) + return rewriteValueAMD64_OpBswap64_0(v) case OpClosureCall: - return rewriteValueAMD64_OpClosureCall(v) + return rewriteValueAMD64_OpClosureCall_0(v) case OpCom16: - return rewriteValueAMD64_OpCom16(v) + return rewriteValueAMD64_OpCom16_0(v) case OpCom32: - return rewriteValueAMD64_OpCom32(v) + return rewriteValueAMD64_OpCom32_0(v) case OpCom64: - return rewriteValueAMD64_OpCom64(v) + return rewriteValueAMD64_OpCom64_0(v) case OpCom8: - return rewriteValueAMD64_OpCom8(v) + return rewriteValueAMD64_OpCom8_0(v) case OpConst16: - return rewriteValueAMD64_OpConst16(v) + return rewriteValueAMD64_OpConst16_0(v) case OpConst32: - return rewriteValueAMD64_OpConst32(v) + return rewriteValueAMD64_OpConst32_0(v) case OpConst32F: - return rewriteValueAMD64_OpConst32F(v) + return rewriteValueAMD64_OpConst32F_0(v) case OpConst64: - return rewriteValueAMD64_OpConst64(v) + return rewriteValueAMD64_OpConst64_0(v) case OpConst64F: - return rewriteValueAMD64_OpConst64F(v) + return rewriteValueAMD64_OpConst64F_0(v) case OpConst8: - return rewriteValueAMD64_OpConst8(v) + return rewriteValueAMD64_OpConst8_0(v) case OpConstBool: - return rewriteValueAMD64_OpConstBool(v) + return rewriteValueAMD64_OpConstBool_0(v) case OpConstNil: - return rewriteValueAMD64_OpConstNil(v) + return rewriteValueAMD64_OpConstNil_0(v) case OpConvert: - return rewriteValueAMD64_OpConvert(v) + return rewriteValueAMD64_OpConvert_0(v) case OpCtz32: - return rewriteValueAMD64_OpCtz32(v) + return rewriteValueAMD64_OpCtz32_0(v) case OpCtz64: - return rewriteValueAMD64_OpCtz64(v) + return rewriteValueAMD64_OpCtz64_0(v) case OpCvt32Fto32: - return rewriteValueAMD64_OpCvt32Fto32(v) + return rewriteValueAMD64_OpCvt32Fto32_0(v) case OpCvt32Fto64: - return rewriteValueAMD64_OpCvt32Fto64(v) + return rewriteValueAMD64_OpCvt32Fto64_0(v) case OpCvt32Fto64F: - return rewriteValueAMD64_OpCvt32Fto64F(v) + return rewriteValueAMD64_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValueAMD64_OpCvt32to32F(v) + return rewriteValueAMD64_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueAMD64_OpCvt32to64F(v) + return rewriteValueAMD64_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueAMD64_OpCvt64Fto32(v) + return rewriteValueAMD64_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueAMD64_OpCvt64Fto32F(v) + return rewriteValueAMD64_OpCvt64Fto32F_0(v) case OpCvt64Fto64: - return rewriteValueAMD64_OpCvt64Fto64(v) + return rewriteValueAMD64_OpCvt64Fto64_0(v) case OpCvt64to32F: - return rewriteValueAMD64_OpCvt64to32F(v) + return rewriteValueAMD64_OpCvt64to32F_0(v) case OpCvt64to64F: - return rewriteValueAMD64_OpCvt64to64F(v) + return rewriteValueAMD64_OpCvt64to64F_0(v) case OpDiv128u: - return rewriteValueAMD64_OpDiv128u(v) + return rewriteValueAMD64_OpDiv128u_0(v) case OpDiv16: - return rewriteValueAMD64_OpDiv16(v) + return rewriteValueAMD64_OpDiv16_0(v) case OpDiv16u: - return rewriteValueAMD64_OpDiv16u(v) + return rewriteValueAMD64_OpDiv16u_0(v) case OpDiv32: - return rewriteValueAMD64_OpDiv32(v) + return rewriteValueAMD64_OpDiv32_0(v) case OpDiv32F: - return rewriteValueAMD64_OpDiv32F(v) + return rewriteValueAMD64_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueAMD64_OpDiv32u(v) + return rewriteValueAMD64_OpDiv32u_0(v) case OpDiv64: - return rewriteValueAMD64_OpDiv64(v) + return rewriteValueAMD64_OpDiv64_0(v) case OpDiv64F: - return rewriteValueAMD64_OpDiv64F(v) + return rewriteValueAMD64_OpDiv64F_0(v) case OpDiv64u: - return rewriteValueAMD64_OpDiv64u(v) + return rewriteValueAMD64_OpDiv64u_0(v) case OpDiv8: - return rewriteValueAMD64_OpDiv8(v) + return rewriteValueAMD64_OpDiv8_0(v) case OpDiv8u: - return rewriteValueAMD64_OpDiv8u(v) + return rewriteValueAMD64_OpDiv8u_0(v) case OpEq16: - return rewriteValueAMD64_OpEq16(v) + return rewriteValueAMD64_OpEq16_0(v) case OpEq32: - return rewriteValueAMD64_OpEq32(v) + return rewriteValueAMD64_OpEq32_0(v) case OpEq32F: - return rewriteValueAMD64_OpEq32F(v) + return rewriteValueAMD64_OpEq32F_0(v) case OpEq64: - return rewriteValueAMD64_OpEq64(v) + return rewriteValueAMD64_OpEq64_0(v) case OpEq64F: - return rewriteValueAMD64_OpEq64F(v) + return rewriteValueAMD64_OpEq64F_0(v) case OpEq8: - return rewriteValueAMD64_OpEq8(v) + return rewriteValueAMD64_OpEq8_0(v) case OpEqB: - return rewriteValueAMD64_OpEqB(v) + return rewriteValueAMD64_OpEqB_0(v) case OpEqPtr: - return rewriteValueAMD64_OpEqPtr(v) + return rewriteValueAMD64_OpEqPtr_0(v) case OpGeq16: - return rewriteValueAMD64_OpGeq16(v) + return rewriteValueAMD64_OpGeq16_0(v) case OpGeq16U: - return rewriteValueAMD64_OpGeq16U(v) + return rewriteValueAMD64_OpGeq16U_0(v) case OpGeq32: - return rewriteValueAMD64_OpGeq32(v) + return rewriteValueAMD64_OpGeq32_0(v) case OpGeq32F: - return rewriteValueAMD64_OpGeq32F(v) + return rewriteValueAMD64_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueAMD64_OpGeq32U(v) + return rewriteValueAMD64_OpGeq32U_0(v) case OpGeq64: - return rewriteValueAMD64_OpGeq64(v) + return rewriteValueAMD64_OpGeq64_0(v) case OpGeq64F: - return rewriteValueAMD64_OpGeq64F(v) + return rewriteValueAMD64_OpGeq64F_0(v) case OpGeq64U: - return rewriteValueAMD64_OpGeq64U(v) + return rewriteValueAMD64_OpGeq64U_0(v) case OpGeq8: - return rewriteValueAMD64_OpGeq8(v) + return rewriteValueAMD64_OpGeq8_0(v) case OpGeq8U: - return rewriteValueAMD64_OpGeq8U(v) + return rewriteValueAMD64_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueAMD64_OpGetClosurePtr(v) + return rewriteValueAMD64_OpGetClosurePtr_0(v) case OpGetG: - return rewriteValueAMD64_OpGetG(v) + return rewriteValueAMD64_OpGetG_0(v) case OpGreater16: - return rewriteValueAMD64_OpGreater16(v) + return rewriteValueAMD64_OpGreater16_0(v) case OpGreater16U: - return rewriteValueAMD64_OpGreater16U(v) + return rewriteValueAMD64_OpGreater16U_0(v) case OpGreater32: - return rewriteValueAMD64_OpGreater32(v) + return rewriteValueAMD64_OpGreater32_0(v) case OpGreater32F: - return rewriteValueAMD64_OpGreater32F(v) + return rewriteValueAMD64_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueAMD64_OpGreater32U(v) + return rewriteValueAMD64_OpGreater32U_0(v) case OpGreater64: - return rewriteValueAMD64_OpGreater64(v) + return rewriteValueAMD64_OpGreater64_0(v) case OpGreater64F: - return rewriteValueAMD64_OpGreater64F(v) + return rewriteValueAMD64_OpGreater64F_0(v) case OpGreater64U: - return rewriteValueAMD64_OpGreater64U(v) + return rewriteValueAMD64_OpGreater64U_0(v) case OpGreater8: - return rewriteValueAMD64_OpGreater8(v) + return rewriteValueAMD64_OpGreater8_0(v) case OpGreater8U: - return rewriteValueAMD64_OpGreater8U(v) + return rewriteValueAMD64_OpGreater8U_0(v) case OpHmul32: - return rewriteValueAMD64_OpHmul32(v) + return rewriteValueAMD64_OpHmul32_0(v) case OpHmul32u: - return rewriteValueAMD64_OpHmul32u(v) + return rewriteValueAMD64_OpHmul32u_0(v) case OpHmul64: - return rewriteValueAMD64_OpHmul64(v) + return rewriteValueAMD64_OpHmul64_0(v) case OpHmul64u: - return rewriteValueAMD64_OpHmul64u(v) + return rewriteValueAMD64_OpHmul64u_0(v) case OpInt64Hi: - return rewriteValueAMD64_OpInt64Hi(v) + return rewriteValueAMD64_OpInt64Hi_0(v) case OpInterCall: - return rewriteValueAMD64_OpInterCall(v) + return rewriteValueAMD64_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueAMD64_OpIsInBounds(v) + return rewriteValueAMD64_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueAMD64_OpIsNonNil(v) + return rewriteValueAMD64_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueAMD64_OpIsSliceInBounds(v) + return rewriteValueAMD64_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueAMD64_OpLeq16(v) + return rewriteValueAMD64_OpLeq16_0(v) case OpLeq16U: - return rewriteValueAMD64_OpLeq16U(v) + return rewriteValueAMD64_OpLeq16U_0(v) case OpLeq32: - return rewriteValueAMD64_OpLeq32(v) + return rewriteValueAMD64_OpLeq32_0(v) case OpLeq32F: - return rewriteValueAMD64_OpLeq32F(v) + return rewriteValueAMD64_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueAMD64_OpLeq32U(v) + return rewriteValueAMD64_OpLeq32U_0(v) case OpLeq64: - return rewriteValueAMD64_OpLeq64(v) + return rewriteValueAMD64_OpLeq64_0(v) case OpLeq64F: - return rewriteValueAMD64_OpLeq64F(v) + return rewriteValueAMD64_OpLeq64F_0(v) case OpLeq64U: - return rewriteValueAMD64_OpLeq64U(v) + return rewriteValueAMD64_OpLeq64U_0(v) case OpLeq8: - return rewriteValueAMD64_OpLeq8(v) + return rewriteValueAMD64_OpLeq8_0(v) case OpLeq8U: - return rewriteValueAMD64_OpLeq8U(v) + return rewriteValueAMD64_OpLeq8U_0(v) case OpLess16: - return rewriteValueAMD64_OpLess16(v) + return rewriteValueAMD64_OpLess16_0(v) case OpLess16U: - return rewriteValueAMD64_OpLess16U(v) + return rewriteValueAMD64_OpLess16U_0(v) case OpLess32: - return rewriteValueAMD64_OpLess32(v) + return rewriteValueAMD64_OpLess32_0(v) case OpLess32F: - return rewriteValueAMD64_OpLess32F(v) + return rewriteValueAMD64_OpLess32F_0(v) case OpLess32U: - return rewriteValueAMD64_OpLess32U(v) + return rewriteValueAMD64_OpLess32U_0(v) case OpLess64: - return rewriteValueAMD64_OpLess64(v) + return rewriteValueAMD64_OpLess64_0(v) case OpLess64F: - return rewriteValueAMD64_OpLess64F(v) + return rewriteValueAMD64_OpLess64F_0(v) case OpLess64U: - return rewriteValueAMD64_OpLess64U(v) + return rewriteValueAMD64_OpLess64U_0(v) case OpLess8: - return rewriteValueAMD64_OpLess8(v) + return rewriteValueAMD64_OpLess8_0(v) case OpLess8U: - return rewriteValueAMD64_OpLess8U(v) + return rewriteValueAMD64_OpLess8U_0(v) case OpLoad: - return rewriteValueAMD64_OpLoad(v) + return rewriteValueAMD64_OpLoad_0(v) case OpLsh16x16: - return rewriteValueAMD64_OpLsh16x16(v) + return rewriteValueAMD64_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueAMD64_OpLsh16x32(v) + return rewriteValueAMD64_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueAMD64_OpLsh16x64(v) + return rewriteValueAMD64_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueAMD64_OpLsh16x8(v) + return rewriteValueAMD64_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueAMD64_OpLsh32x16(v) + return rewriteValueAMD64_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueAMD64_OpLsh32x32(v) + return rewriteValueAMD64_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueAMD64_OpLsh32x64(v) + return rewriteValueAMD64_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueAMD64_OpLsh32x8(v) + return rewriteValueAMD64_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValueAMD64_OpLsh64x16(v) + return rewriteValueAMD64_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValueAMD64_OpLsh64x32(v) + return rewriteValueAMD64_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValueAMD64_OpLsh64x64(v) + return rewriteValueAMD64_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValueAMD64_OpLsh64x8(v) + return rewriteValueAMD64_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValueAMD64_OpLsh8x16(v) + return rewriteValueAMD64_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueAMD64_OpLsh8x32(v) + return rewriteValueAMD64_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueAMD64_OpLsh8x64(v) + return rewriteValueAMD64_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueAMD64_OpLsh8x8(v) + return rewriteValueAMD64_OpLsh8x8_0(v) case OpMod16: - return rewriteValueAMD64_OpMod16(v) + return rewriteValueAMD64_OpMod16_0(v) case OpMod16u: - return rewriteValueAMD64_OpMod16u(v) + return rewriteValueAMD64_OpMod16u_0(v) case OpMod32: - return rewriteValueAMD64_OpMod32(v) + return rewriteValueAMD64_OpMod32_0(v) case OpMod32u: - return rewriteValueAMD64_OpMod32u(v) + return rewriteValueAMD64_OpMod32u_0(v) case OpMod64: - return rewriteValueAMD64_OpMod64(v) + return rewriteValueAMD64_OpMod64_0(v) case OpMod64u: - return rewriteValueAMD64_OpMod64u(v) + return rewriteValueAMD64_OpMod64u_0(v) case OpMod8: - return rewriteValueAMD64_OpMod8(v) + return rewriteValueAMD64_OpMod8_0(v) case OpMod8u: - return rewriteValueAMD64_OpMod8u(v) + return rewriteValueAMD64_OpMod8u_0(v) case OpMove: - return rewriteValueAMD64_OpMove(v) + return rewriteValueAMD64_OpMove_0(v) || rewriteValueAMD64_OpMove_10(v) case OpMul16: - return rewriteValueAMD64_OpMul16(v) + return rewriteValueAMD64_OpMul16_0(v) case OpMul32: - return rewriteValueAMD64_OpMul32(v) + return rewriteValueAMD64_OpMul32_0(v) case OpMul32F: - return rewriteValueAMD64_OpMul32F(v) + return rewriteValueAMD64_OpMul32F_0(v) case OpMul64: - return rewriteValueAMD64_OpMul64(v) + return rewriteValueAMD64_OpMul64_0(v) case OpMul64F: - return rewriteValueAMD64_OpMul64F(v) + return rewriteValueAMD64_OpMul64F_0(v) case OpMul64uhilo: - return rewriteValueAMD64_OpMul64uhilo(v) + return rewriteValueAMD64_OpMul64uhilo_0(v) case OpMul8: - return rewriteValueAMD64_OpMul8(v) + return rewriteValueAMD64_OpMul8_0(v) case OpNeg16: - return rewriteValueAMD64_OpNeg16(v) + return rewriteValueAMD64_OpNeg16_0(v) case OpNeg32: - return rewriteValueAMD64_OpNeg32(v) + return rewriteValueAMD64_OpNeg32_0(v) case OpNeg32F: - return rewriteValueAMD64_OpNeg32F(v) + return rewriteValueAMD64_OpNeg32F_0(v) case OpNeg64: - return rewriteValueAMD64_OpNeg64(v) + return rewriteValueAMD64_OpNeg64_0(v) case OpNeg64F: - return rewriteValueAMD64_OpNeg64F(v) + return rewriteValueAMD64_OpNeg64F_0(v) case OpNeg8: - return rewriteValueAMD64_OpNeg8(v) + return rewriteValueAMD64_OpNeg8_0(v) case OpNeq16: - return rewriteValueAMD64_OpNeq16(v) + return rewriteValueAMD64_OpNeq16_0(v) case OpNeq32: - return rewriteValueAMD64_OpNeq32(v) + return rewriteValueAMD64_OpNeq32_0(v) case OpNeq32F: - return rewriteValueAMD64_OpNeq32F(v) + return rewriteValueAMD64_OpNeq32F_0(v) case OpNeq64: - return rewriteValueAMD64_OpNeq64(v) + return rewriteValueAMD64_OpNeq64_0(v) case OpNeq64F: - return rewriteValueAMD64_OpNeq64F(v) + return rewriteValueAMD64_OpNeq64F_0(v) case OpNeq8: - return rewriteValueAMD64_OpNeq8(v) + return rewriteValueAMD64_OpNeq8_0(v) case OpNeqB: - return rewriteValueAMD64_OpNeqB(v) + return rewriteValueAMD64_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueAMD64_OpNeqPtr(v) + return rewriteValueAMD64_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueAMD64_OpNilCheck(v) + return rewriteValueAMD64_OpNilCheck_0(v) case OpNot: - return rewriteValueAMD64_OpNot(v) + return rewriteValueAMD64_OpNot_0(v) case OpOffPtr: - return rewriteValueAMD64_OpOffPtr(v) + return rewriteValueAMD64_OpOffPtr_0(v) case OpOr16: - return rewriteValueAMD64_OpOr16(v) + return rewriteValueAMD64_OpOr16_0(v) case OpOr32: - return rewriteValueAMD64_OpOr32(v) + return rewriteValueAMD64_OpOr32_0(v) case OpOr64: - return rewriteValueAMD64_OpOr64(v) + return rewriteValueAMD64_OpOr64_0(v) case OpOr8: - return rewriteValueAMD64_OpOr8(v) + return rewriteValueAMD64_OpOr8_0(v) case OpOrB: - return rewriteValueAMD64_OpOrB(v) + return rewriteValueAMD64_OpOrB_0(v) case OpPopCount16: - return rewriteValueAMD64_OpPopCount16(v) + return rewriteValueAMD64_OpPopCount16_0(v) case OpPopCount32: - return rewriteValueAMD64_OpPopCount32(v) + return rewriteValueAMD64_OpPopCount32_0(v) case OpPopCount64: - return rewriteValueAMD64_OpPopCount64(v) + return rewriteValueAMD64_OpPopCount64_0(v) case OpPopCount8: - return rewriteValueAMD64_OpPopCount8(v) + return rewriteValueAMD64_OpPopCount8_0(v) case OpRound32F: - return rewriteValueAMD64_OpRound32F(v) + return rewriteValueAMD64_OpRound32F_0(v) case OpRound64F: - return rewriteValueAMD64_OpRound64F(v) + return rewriteValueAMD64_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueAMD64_OpRsh16Ux16(v) + return rewriteValueAMD64_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueAMD64_OpRsh16Ux32(v) + return rewriteValueAMD64_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueAMD64_OpRsh16Ux64(v) + return rewriteValueAMD64_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueAMD64_OpRsh16Ux8(v) + return rewriteValueAMD64_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueAMD64_OpRsh16x16(v) + return rewriteValueAMD64_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueAMD64_OpRsh16x32(v) + return rewriteValueAMD64_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueAMD64_OpRsh16x64(v) + return rewriteValueAMD64_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueAMD64_OpRsh16x8(v) + return rewriteValueAMD64_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueAMD64_OpRsh32Ux16(v) + return rewriteValueAMD64_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueAMD64_OpRsh32Ux32(v) + return rewriteValueAMD64_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueAMD64_OpRsh32Ux64(v) + return rewriteValueAMD64_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueAMD64_OpRsh32Ux8(v) + return rewriteValueAMD64_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueAMD64_OpRsh32x16(v) + return rewriteValueAMD64_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueAMD64_OpRsh32x32(v) + return rewriteValueAMD64_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueAMD64_OpRsh32x64(v) + return rewriteValueAMD64_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueAMD64_OpRsh32x8(v) + return rewriteValueAMD64_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValueAMD64_OpRsh64Ux16(v) + return rewriteValueAMD64_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValueAMD64_OpRsh64Ux32(v) + return rewriteValueAMD64_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValueAMD64_OpRsh64Ux64(v) + return rewriteValueAMD64_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValueAMD64_OpRsh64Ux8(v) + return rewriteValueAMD64_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValueAMD64_OpRsh64x16(v) + return rewriteValueAMD64_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValueAMD64_OpRsh64x32(v) + return rewriteValueAMD64_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValueAMD64_OpRsh64x64(v) + return rewriteValueAMD64_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValueAMD64_OpRsh64x8(v) + return rewriteValueAMD64_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValueAMD64_OpRsh8Ux16(v) + return rewriteValueAMD64_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueAMD64_OpRsh8Ux32(v) + return rewriteValueAMD64_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueAMD64_OpRsh8Ux64(v) + return rewriteValueAMD64_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueAMD64_OpRsh8Ux8(v) + return rewriteValueAMD64_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueAMD64_OpRsh8x16(v) + return rewriteValueAMD64_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueAMD64_OpRsh8x32(v) + return rewriteValueAMD64_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueAMD64_OpRsh8x64(v) + return rewriteValueAMD64_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueAMD64_OpRsh8x8(v) + return rewriteValueAMD64_OpRsh8x8_0(v) case OpSelect0: - return rewriteValueAMD64_OpSelect0(v) + return rewriteValueAMD64_OpSelect0_0(v) case OpSelect1: - return rewriteValueAMD64_OpSelect1(v) + return rewriteValueAMD64_OpSelect1_0(v) case OpSignExt16to32: - return rewriteValueAMD64_OpSignExt16to32(v) + return rewriteValueAMD64_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValueAMD64_OpSignExt16to64(v) + return rewriteValueAMD64_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValueAMD64_OpSignExt32to64(v) + return rewriteValueAMD64_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValueAMD64_OpSignExt8to16(v) + return rewriteValueAMD64_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueAMD64_OpSignExt8to32(v) + return rewriteValueAMD64_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValueAMD64_OpSignExt8to64(v) + return rewriteValueAMD64_OpSignExt8to64_0(v) case OpSlicemask: - return rewriteValueAMD64_OpSlicemask(v) + return rewriteValueAMD64_OpSlicemask_0(v) case OpSqrt: - return rewriteValueAMD64_OpSqrt(v) + return rewriteValueAMD64_OpSqrt_0(v) case OpStaticCall: - return rewriteValueAMD64_OpStaticCall(v) + return rewriteValueAMD64_OpStaticCall_0(v) case OpStore: - return rewriteValueAMD64_OpStore(v) + return rewriteValueAMD64_OpStore_0(v) case OpSub16: - return rewriteValueAMD64_OpSub16(v) + return rewriteValueAMD64_OpSub16_0(v) case OpSub32: - return rewriteValueAMD64_OpSub32(v) + return rewriteValueAMD64_OpSub32_0(v) case OpSub32F: - return rewriteValueAMD64_OpSub32F(v) + return rewriteValueAMD64_OpSub32F_0(v) case OpSub64: - return rewriteValueAMD64_OpSub64(v) + return rewriteValueAMD64_OpSub64_0(v) case OpSub64F: - return rewriteValueAMD64_OpSub64F(v) + return rewriteValueAMD64_OpSub64F_0(v) case OpSub8: - return rewriteValueAMD64_OpSub8(v) + return rewriteValueAMD64_OpSub8_0(v) case OpSubPtr: - return rewriteValueAMD64_OpSubPtr(v) + return rewriteValueAMD64_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueAMD64_OpTrunc16to8(v) + return rewriteValueAMD64_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueAMD64_OpTrunc32to16(v) + return rewriteValueAMD64_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueAMD64_OpTrunc32to8(v) + return rewriteValueAMD64_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValueAMD64_OpTrunc64to16(v) + return rewriteValueAMD64_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValueAMD64_OpTrunc64to32(v) + return rewriteValueAMD64_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValueAMD64_OpTrunc64to8(v) + return rewriteValueAMD64_OpTrunc64to8_0(v) case OpXor16: - return rewriteValueAMD64_OpXor16(v) + return rewriteValueAMD64_OpXor16_0(v) case OpXor32: - return rewriteValueAMD64_OpXor32(v) + return rewriteValueAMD64_OpXor32_0(v) case OpXor64: - return rewriteValueAMD64_OpXor64(v) + return rewriteValueAMD64_OpXor64_0(v) case OpXor8: - return rewriteValueAMD64_OpXor8(v) + return rewriteValueAMD64_OpXor8_0(v) case OpZero: - return rewriteValueAMD64_OpZero(v) + return rewriteValueAMD64_OpZero_0(v) || rewriteValueAMD64_OpZero_10(v) case OpZeroExt16to32: - return rewriteValueAMD64_OpZeroExt16to32(v) + return rewriteValueAMD64_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValueAMD64_OpZeroExt16to64(v) + return rewriteValueAMD64_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValueAMD64_OpZeroExt32to64(v) + return rewriteValueAMD64_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValueAMD64_OpZeroExt8to16(v) + return rewriteValueAMD64_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueAMD64_OpZeroExt8to32(v) + return rewriteValueAMD64_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValueAMD64_OpZeroExt8to64(v) + return rewriteValueAMD64_OpZeroExt8to64_0(v) } return false } -func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDL_0(v *Value) bool { // match: (ADDL x (MOVLconst [c])) // cond: // result: (ADDLconst [c] x) @@ -1077,6 +1077,9 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ADDL_10(v *Value) bool { // match: (ADDL x l:(MOVLload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (ADDLmem x [off] {sym} ptr mem) @@ -1127,7 +1130,7 @@ func rewriteValueAMD64_OpAMD64ADDL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDLconst_0(v *Value) bool { // match: (ADDLconst [c] x) // cond: int32(c)==0 // result: x @@ -1195,7 +1198,7 @@ func rewriteValueAMD64_OpAMD64ADDLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDQ_0(v *Value) bool { // match: (ADDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ADDQconst [c] x) @@ -1392,6 +1395,9 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ADDQ_10(v *Value) bool { // match: (ADDQ x (ADDQ y y)) // cond: // result: (LEAQ2 x y) @@ -1578,6 +1584,9 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ADDQ_20(v *Value) bool { // match: (ADDQ x (NEGQ y)) // cond: // result: (SUBQ x y) @@ -1658,7 +1667,7 @@ func rewriteValueAMD64_OpAMD64ADDQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDQconst_0(v *Value) bool { // match: (ADDQconst [c] (ADDQ x y)) // cond: // result: (LEAQ1 [c] x y) @@ -1837,7 +1846,7 @@ func rewriteValueAMD64_OpAMD64ADDQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDSD_0(v *Value) bool { // match: (ADDSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (ADDSDmem x [off] {sym} ptr mem) @@ -1888,7 +1897,7 @@ func rewriteValueAMD64_OpAMD64ADDSD(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool { +func rewriteValueAMD64_OpAMD64ADDSS_0(v *Value) bool { // match: (ADDSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (ADDSSmem x [off] {sym} ptr mem) @@ -1939,7 +1948,7 @@ func rewriteValueAMD64_OpAMD64ADDSS(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool { +func rewriteValueAMD64_OpAMD64ANDL_0(v *Value) bool { // match: (ANDL x (MOVLconst [c])) // cond: // result: (ANDLconst [c] x) @@ -2033,7 +2042,7 @@ func rewriteValueAMD64_OpAMD64ANDL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ANDLconst_0(v *Value) bool { // match: (ANDLconst [c] (ANDLconst [d] x)) // cond: // result: (ANDLconst [c & d] x) @@ -2116,7 +2125,7 @@ func rewriteValueAMD64_OpAMD64ANDLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64ANDQ_0(v *Value) bool { // match: (ANDQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ANDQconst [c] x) @@ -2216,7 +2225,7 @@ func rewriteValueAMD64_OpAMD64ANDQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ANDQconst_0(v *Value) bool { // match: (ANDQconst [c] (ANDQconst [d] x)) // cond: // result: (ANDQconst [c & d] x) @@ -2309,7 +2318,7 @@ func rewriteValueAMD64_OpAMD64ANDQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64BSFQ_0(v *Value) bool { b := v.Block _ = b // match: (BSFQ (ORQconst [1<<8] (MOVBQZX x))) @@ -2362,7 +2371,7 @@ func rewriteValueAMD64_OpAMD64BSFQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64BTQconst_0(v *Value) bool { // match: (BTQconst [c] x) // cond: c < 32 // result: (BTLconst [c] x) @@ -2379,7 +2388,7 @@ func rewriteValueAMD64_OpAMD64BTQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMOVQEQ_0(v *Value) bool { // match: (CMOVQEQ x _ (Select1 (BSFQ (ORQconst [c] _)))) // cond: c != 0 // result: x @@ -2408,7 +2417,7 @@ func rewriteValueAMD64_OpAMD64CMOVQEQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPB_0(v *Value) bool { b := v.Block _ = b // match: (CMPB x (MOVLconst [c])) @@ -2445,7 +2454,7 @@ func rewriteValueAMD64_OpAMD64CMPB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPBconst_0(v *Value) bool { // match: (CMPBconst (MOVLconst [x]) [y]) // cond: int8(x)==int8(y) // result: (FlagEQ) @@ -2593,7 +2602,7 @@ func rewriteValueAMD64_OpAMD64CMPBconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPL_0(v *Value) bool { b := v.Block _ = b // match: (CMPL x (MOVLconst [c])) @@ -2630,7 +2639,7 @@ func rewriteValueAMD64_OpAMD64CMPL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPLconst_0(v *Value) bool { // match: (CMPLconst (MOVLconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -2794,7 +2803,7 @@ func rewriteValueAMD64_OpAMD64CMPLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPQ_0(v *Value) bool { b := v.Block _ = b // match: (CMPQ x (MOVQconst [c])) @@ -2837,7 +2846,7 @@ func rewriteValueAMD64_OpAMD64CMPQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64CMPQconst_0(v *Value) bool { // match: (CMPQconst (NEGQ (ADDQconst [-16] (ANDQconst [15] _))) [32]) // cond: // result: (FlagLT_ULT) @@ -3019,6 +3028,9 @@ func rewriteValueAMD64_OpAMD64CMPQconst(v *Value) bool { 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< x x)) @@ -12245,6 +12271,11 @@ func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool { 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 [log2(c-8)] x) x) @@ -12329,7 +12360,7 @@ func rewriteValueAMD64_OpAMD64MULQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool { +func rewriteValueAMD64_OpAMD64MULSD_0(v *Value) bool { // match: (MULSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (MULSDmem x [off] {sym} ptr mem) @@ -12380,7 +12411,7 @@ func rewriteValueAMD64_OpAMD64MULSD(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool { +func rewriteValueAMD64_OpAMD64MULSS_0(v *Value) bool { // match: (MULSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (MULSSmem x [off] {sym} ptr mem) @@ -12431,7 +12462,7 @@ func rewriteValueAMD64_OpAMD64MULSS(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool { +func rewriteValueAMD64_OpAMD64NEGL_0(v *Value) bool { // match: (NEGL (MOVLconst [c])) // cond: // result: (MOVLconst [int64(int32(-c))]) @@ -12447,7 +12478,7 @@ func rewriteValueAMD64_OpAMD64NEGL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64NEGQ_0(v *Value) bool { // match: (NEGQ (MOVQconst [c])) // cond: // result: (MOVQconst [-c]) @@ -12485,7 +12516,7 @@ func rewriteValueAMD64_OpAMD64NEGQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool { +func rewriteValueAMD64_OpAMD64NOTL_0(v *Value) bool { // match: (NOTL (MOVLconst [c])) // cond: // result: (MOVLconst [^c]) @@ -12501,7 +12532,7 @@ func rewriteValueAMD64_OpAMD64NOTL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64NOTQ_0(v *Value) bool { // match: (NOTQ (MOVQconst [c])) // cond: // result: (MOVQconst [^c]) @@ -12517,11 +12548,7 @@ func rewriteValueAMD64_OpAMD64NOTQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { - b := v.Block - _ = b - types := &b.Func.Config.Types - _ = types +func rewriteValueAMD64_OpAMD64ORL_0(v *Value) bool { // match: (ORL x (MOVLconst [c])) // cond: // result: (ORLconst [c] x) @@ -12842,6 +12869,9 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_10(v *Value) bool { // match: (ORL (ANDL (SHRL x (NEGQ y)) (SBBLcarrymask (CMPQconst (NEGQ (ADDQconst (ANDQconst y [31]) [-32])) [32]))) (SHLL x y)) // cond: // result: (ROLL x y) @@ -13492,6 +13522,9 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_20(v *Value) bool { // match: (ORL (SHRL x y) (ANDL (SHLL x (NEGL y)) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [31]) [-32])) [32])))) // cond: // result: (RORL x y) @@ -14286,6 +14319,9 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_30(v *Value) bool { // match: (ORL (ANDL (SHRW x (NEGL (ADDLconst (ANDLconst y [15]) [-16]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [15]) [-16])) [16]))) (SHLL x (ANDLconst y [15]))) // cond: v.Type.Size() == 2 // result: (ROLW x y) @@ -15032,6 +15068,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_40(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORL (SHLL x (ANDLconst y [ 7])) (ANDL (SHRB x (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8]))) (SBBLcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [ 7]) [ -8])) [ 8])))) // cond: v.Type.Size() == 1 // result: (ROLB x y) @@ -15659,6 +15702,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_50(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORL sh:(SHLLconst [8] x1:(MOVBload [i1] {s} p mem)) x0:(MOVBload [i0] {s} p mem)) // cond: i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVWload [i0] {s} p mem) @@ -16190,6 +16240,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 [i0] {s} p idx mem) @@ -16700,6 +16757,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_70(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORL sh:(SHLLconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} p idx mem)) // cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem) @@ -17308,6 +17372,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 (SHLLconst [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y) @@ -17942,6 +18013,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 [8] (MOVWload [i0] {s} p mem)) @@ -18529,6 +18607,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 [8] (MOVWloadidx1 [i0] {s} p idx mem)) @@ -19134,6 +19219,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 (MOVLloadidx1 [i0] {s} p idx mem)) @@ -19811,6 +19903,13 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { 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 (SHLLconst [j1] (ROLWconst [8] (MOVWloadidx1 [i0] {s} p idx mem))) y) @@ -20447,6 +20546,9 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORL_130(v *Value) bool { // match: (ORL l:(MOVLload [off] {sym} ptr mem) x) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (ORLmem x [off] {sym} ptr mem) @@ -20473,7 +20575,7 @@ func rewriteValueAMD64_OpAMD64ORL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ORLconst_0(v *Value) bool { // match: (ORLconst [c] x) // cond: int32(c)==0 // result: x @@ -20516,11 +20618,7 @@ func rewriteValueAMD64_OpAMD64ORLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { - b := v.Block - _ = b - types := &b.Func.Config.Types - _ = types +func rewriteValueAMD64_OpAMD64ORQ_0(v *Value) bool { // match: (ORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (ORQconst [c] x) @@ -20999,6 +21097,9 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORQ_10(v *Value) bool { // match: (ORQ (ANDQ (SHRQ x (NEGL y)) (SBBQcarrymask (CMPLconst (NEGL (ADDLconst (ANDLconst y [63]) [-64])) [64]))) (SHLQ x y)) // cond: // result: (ROLQ x y) @@ -21649,6 +21750,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORQ_20(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORQ x x) // cond: // result: x @@ -22118,6 +22226,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j0] (MOVWload [i0] {s} p mem)) y) @@ -22673,6 +22788,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 [i0] {s} p idx mem) @@ -23183,6 +23305,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueAMD64_OpAMD64ORQ_50(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORQ sh:(SHLQconst [16] x1:(MOVWloadidx1 [i1] {s} idx p mem)) x0:(MOVWloadidx1 [i0] {s} idx p mem)) // cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVLloadidx1 [i0] {s} p idx mem) @@ -23707,6 +23836,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y) @@ -24357,6 +24493,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j0] (MOVWloadidx1 [i0] {s} p idx mem)) y) @@ -25007,6 +25150,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y) @@ -25657,6 +25807,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j0] (MOVLloadidx1 [i0] {s} p idx mem)) y) @@ -26245,6 +26402,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j1] (ROLWconst [8] (MOVWload [i0] {s} p mem))) y) @@ -26882,6 +27046,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 [8] (MOVWloadidx1 [i0] {s} p idx mem)) @@ -27513,6 +27684,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (MOVLloadidx1 [i0] {s} p idx mem)) @@ -28136,6 +28314,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j1] (ROLWconst [8] (MOVWloadidx1 [i0] {s} p idx mem))) y) @@ -28816,6 +29001,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j1] (ROLWconst [8] (MOVWloadidx1 [i0] {s} p idx mem))) y) @@ -29561,6 +29753,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j1] (BSWAPL (MOVLloadidx1 [i0] {s} p idx mem))) y) @@ -30371,6 +30570,13 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { 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 (SHLQconst [j1] (BSWAPL (MOVLloadidx1 [i0] {s} p idx mem))) y) @@ -30502,7 +30708,7 @@ func rewriteValueAMD64_OpAMD64ORQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ORQconst_0(v *Value) bool { // match: (ORQconst [0] x) // cond: // result: x @@ -30543,7 +30749,7 @@ func rewriteValueAMD64_OpAMD64ORQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLB_0(v *Value) bool { // match: (ROLB x (NEGQ y)) // cond: // result: (RORB x y) @@ -30606,7 +30812,7 @@ func rewriteValueAMD64_OpAMD64ROLB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLBconst_0(v *Value) bool { // match: (ROLBconst [c] (ROLBconst [d] x)) // cond: // result: (ROLBconst [(c+d)& 7] x) @@ -30638,7 +30844,7 @@ func rewriteValueAMD64_OpAMD64ROLBconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLL_0(v *Value) bool { // match: (ROLL x (NEGQ y)) // cond: // result: (RORL x y) @@ -30701,7 +30907,7 @@ func rewriteValueAMD64_OpAMD64ROLL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLLconst_0(v *Value) bool { // match: (ROLLconst [c] (ROLLconst [d] x)) // cond: // result: (ROLLconst [(c+d)&31] x) @@ -30733,7 +30939,7 @@ func rewriteValueAMD64_OpAMD64ROLLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLQ_0(v *Value) bool { // match: (ROLQ x (NEGQ y)) // cond: // result: (RORQ x y) @@ -30796,7 +31002,7 @@ func rewriteValueAMD64_OpAMD64ROLQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLQconst_0(v *Value) bool { // match: (ROLQconst [c] (ROLQconst [d] x)) // cond: // result: (ROLQconst [(c+d)&63] x) @@ -30828,7 +31034,7 @@ func rewriteValueAMD64_OpAMD64ROLQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLW_0(v *Value) bool { // match: (ROLW x (NEGQ y)) // cond: // result: (RORW x y) @@ -30891,7 +31097,7 @@ func rewriteValueAMD64_OpAMD64ROLW(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64ROLWconst_0(v *Value) bool { // match: (ROLWconst [c] (ROLWconst [d] x)) // cond: // result: (ROLWconst [(c+d)&15] x) @@ -30923,7 +31129,7 @@ func rewriteValueAMD64_OpAMD64ROLWconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64RORB(v *Value) bool { +func rewriteValueAMD64_OpAMD64RORB_0(v *Value) bool { // match: (RORB x (NEGQ y)) // cond: // result: (ROLB x y) @@ -30986,7 +31192,7 @@ func rewriteValueAMD64_OpAMD64RORB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64RORL(v *Value) bool { +func rewriteValueAMD64_OpAMD64RORL_0(v *Value) bool { // match: (RORL x (NEGQ y)) // cond: // result: (ROLL x y) @@ -31049,7 +31255,7 @@ func rewriteValueAMD64_OpAMD64RORL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64RORQ_0(v *Value) bool { // match: (RORQ x (NEGQ y)) // cond: // result: (ROLQ x y) @@ -31112,7 +31318,7 @@ func rewriteValueAMD64_OpAMD64RORQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64RORW(v *Value) bool { +func rewriteValueAMD64_OpAMD64RORW_0(v *Value) bool { // match: (RORW x (NEGQ y)) // cond: // result: (ROLW x y) @@ -31175,7 +31381,7 @@ func rewriteValueAMD64_OpAMD64RORW(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARB(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARB_0(v *Value) bool { // match: (SARB x (MOVQconst [c])) // cond: // result: (SARBconst [min(c&31,7)] x) @@ -31208,7 +31414,7 @@ func rewriteValueAMD64_OpAMD64SARB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARBconst_0(v *Value) bool { // match: (SARBconst x [0]) // cond: // result: x @@ -31238,7 +31444,7 @@ func rewriteValueAMD64_OpAMD64SARBconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARL(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARL_0(v *Value) bool { b := v.Block _ = b // match: (SARL x (MOVQconst [c])) @@ -31453,7 +31659,7 @@ func rewriteValueAMD64_OpAMD64SARL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARLconst_0(v *Value) bool { // match: (SARLconst x [0]) // cond: // result: x @@ -31483,7 +31689,7 @@ func rewriteValueAMD64_OpAMD64SARLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARQ_0(v *Value) bool { b := v.Block _ = b // match: (SARQ x (MOVQconst [c])) @@ -31698,7 +31904,7 @@ func rewriteValueAMD64_OpAMD64SARQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARQconst_0(v *Value) bool { // match: (SARQconst x [0]) // cond: // result: x @@ -31728,7 +31934,7 @@ func rewriteValueAMD64_OpAMD64SARQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARW(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARW_0(v *Value) bool { // match: (SARW x (MOVQconst [c])) // cond: // result: (SARWconst [min(c&31,15)] x) @@ -31761,7 +31967,7 @@ func rewriteValueAMD64_OpAMD64SARW(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SARWconst_0(v *Value) bool { // match: (SARWconst x [0]) // cond: // result: x @@ -31791,7 +31997,7 @@ func rewriteValueAMD64_OpAMD64SARWconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool { +func rewriteValueAMD64_OpAMD64SBBLcarrymask_0(v *Value) bool { // match: (SBBLcarrymask (FlagEQ)) // cond: // result: (MOVLconst [0]) @@ -31854,7 +32060,7 @@ func rewriteValueAMD64_OpAMD64SBBLcarrymask(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool { +func rewriteValueAMD64_OpAMD64SBBQcarrymask_0(v *Value) bool { // match: (SBBQcarrymask (FlagEQ)) // cond: // result: (MOVQconst [0]) @@ -31917,7 +32123,7 @@ func rewriteValueAMD64_OpAMD64SBBQcarrymask(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETA(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETA_0(v *Value) bool { // match: (SETA (InvertFlags x)) // cond: // result: (SETB x) @@ -31993,7 +32199,7 @@ func rewriteValueAMD64_OpAMD64SETA(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETAE_0(v *Value) bool { // match: (SETAE (InvertFlags x)) // cond: // result: (SETBE x) @@ -32069,7 +32275,7 @@ func rewriteValueAMD64_OpAMD64SETAE(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETB(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETB_0(v *Value) bool { // match: (SETB (InvertFlags x)) // cond: // result: (SETA x) @@ -32145,7 +32351,7 @@ func rewriteValueAMD64_OpAMD64SETB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETBE_0(v *Value) bool { // match: (SETBE (InvertFlags x)) // cond: // result: (SETAE x) @@ -32221,7 +32427,7 @@ func rewriteValueAMD64_OpAMD64SETBE(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETEQ_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -32463,6 +32669,9 @@ func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool { v.AuxInt = 1 return true } + return false +} +func rewriteValueAMD64_OpAMD64SETEQ_10(v *Value) bool { // match: (SETEQ (FlagLT_ULT)) // cond: // result: (MOVLconst [0]) @@ -32513,7 +32722,7 @@ func rewriteValueAMD64_OpAMD64SETEQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETG(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETG_0(v *Value) bool { // match: (SETG (InvertFlags x)) // cond: // result: (SETL x) @@ -32589,7 +32798,7 @@ func rewriteValueAMD64_OpAMD64SETG(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETGE_0(v *Value) bool { // match: (SETGE (InvertFlags x)) // cond: // result: (SETLE x) @@ -32665,7 +32874,7 @@ func rewriteValueAMD64_OpAMD64SETGE(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETL(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETL_0(v *Value) bool { // match: (SETL (InvertFlags x)) // cond: // result: (SETG x) @@ -32741,7 +32950,7 @@ func rewriteValueAMD64_OpAMD64SETL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETLE_0(v *Value) bool { // match: (SETLE (InvertFlags x)) // cond: // result: (SETGE x) @@ -32817,7 +33026,7 @@ func rewriteValueAMD64_OpAMD64SETLE(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool { +func rewriteValueAMD64_OpAMD64SETNE_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -33059,6 +33268,9 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool { v.AuxInt = 0 return true } + return false +} +func rewriteValueAMD64_OpAMD64SETNE_10(v *Value) bool { // match: (SETNE (FlagLT_ULT)) // cond: // result: (MOVLconst [1]) @@ -33109,7 +33321,7 @@ func rewriteValueAMD64_OpAMD64SETNE(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHLL_0(v *Value) bool { b := v.Block _ = b // match: (SHLL x (MOVQconst [c])) @@ -33324,7 +33536,7 @@ func rewriteValueAMD64_OpAMD64SHLL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHLLconst_0(v *Value) bool { // match: (SHLLconst x [0]) // cond: // result: x @@ -33340,7 +33552,7 @@ func rewriteValueAMD64_OpAMD64SHLLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHLQ_0(v *Value) bool { b := v.Block _ = b // match: (SHLQ x (MOVQconst [c])) @@ -33555,7 +33767,7 @@ func rewriteValueAMD64_OpAMD64SHLQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHLQconst_0(v *Value) bool { // match: (SHLQconst x [0]) // cond: // result: x @@ -33571,7 +33783,7 @@ func rewriteValueAMD64_OpAMD64SHLQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRB_0(v *Value) bool { // match: (SHRB x (MOVQconst [c])) // cond: c&31 < 8 // result: (SHRBconst [c&31] x) @@ -33642,7 +33854,7 @@ func rewriteValueAMD64_OpAMD64SHRB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRBconst_0(v *Value) bool { // match: (SHRBconst x [0]) // cond: // result: x @@ -33658,7 +33870,7 @@ func rewriteValueAMD64_OpAMD64SHRBconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRL_0(v *Value) bool { b := v.Block _ = b // match: (SHRL x (MOVQconst [c])) @@ -33873,7 +34085,7 @@ func rewriteValueAMD64_OpAMD64SHRL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRLconst_0(v *Value) bool { // match: (SHRLconst x [0]) // cond: // result: x @@ -33889,7 +34101,7 @@ func rewriteValueAMD64_OpAMD64SHRLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRQ_0(v *Value) bool { b := v.Block _ = b // match: (SHRQ x (MOVQconst [c])) @@ -34104,7 +34316,7 @@ func rewriteValueAMD64_OpAMD64SHRQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRQconst_0(v *Value) bool { // match: (SHRQconst x [0]) // cond: // result: x @@ -34120,7 +34332,7 @@ func rewriteValueAMD64_OpAMD64SHRQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRW_0(v *Value) bool { // match: (SHRW x (MOVQconst [c])) // cond: c&31 < 16 // result: (SHRWconst [c&31] x) @@ -34191,7 +34403,7 @@ func rewriteValueAMD64_OpAMD64SHRW(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SHRWconst_0(v *Value) bool { // match: (SHRWconst x [0]) // cond: // result: x @@ -34207,7 +34419,7 @@ func rewriteValueAMD64_OpAMD64SHRWconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBL_0(v *Value) bool { b := v.Block _ = b // match: (SUBL x (MOVLconst [c])) @@ -34280,7 +34492,7 @@ func rewriteValueAMD64_OpAMD64SUBL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBLconst_0(v *Value) bool { // match: (SUBLconst [c] x) // cond: int32(c) == 0 // result: x @@ -34307,7 +34519,7 @@ func rewriteValueAMD64_OpAMD64SUBLconst(v *Value) bool { return true } } -func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBQ_0(v *Value) bool { b := v.Block _ = b // match: (SUBQ x (MOVQconst [c])) @@ -34386,7 +34598,7 @@ func rewriteValueAMD64_OpAMD64SUBQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBQconst_0(v *Value) bool { // match: (SUBQconst [0] x) // cond: // result: x @@ -34449,7 +34661,7 @@ func rewriteValueAMD64_OpAMD64SUBQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBSD_0(v *Value) bool { // match: (SUBSD x l:(MOVSDload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (SUBSDmem x [off] {sym} ptr mem) @@ -34476,7 +34688,7 @@ func rewriteValueAMD64_OpAMD64SUBSD(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool { +func rewriteValueAMD64_OpAMD64SUBSS_0(v *Value) bool { // match: (SUBSS x l:(MOVSSload [off] {sym} ptr mem)) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (SUBSSmem x [off] {sym} ptr mem) @@ -34503,7 +34715,7 @@ func rewriteValueAMD64_OpAMD64SUBSS(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool { +func rewriteValueAMD64_OpAMD64TESTB_0(v *Value) bool { // match: (TESTB (MOVLconst [c]) x) // cond: // result: (TESTBconst [c] x) @@ -34536,7 +34748,7 @@ func rewriteValueAMD64_OpAMD64TESTB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool { +func rewriteValueAMD64_OpAMD64TESTL_0(v *Value) bool { // match: (TESTL (MOVLconst [c]) x) // cond: // result: (TESTLconst [c] x) @@ -34569,7 +34781,7 @@ func rewriteValueAMD64_OpAMD64TESTL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64TESTQ_0(v *Value) bool { // match: (TESTQ (MOVQconst [c]) x) // cond: is32Bit(c) // result: (TESTQconst [c] x) @@ -34608,7 +34820,7 @@ func rewriteValueAMD64_OpAMD64TESTQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool { +func rewriteValueAMD64_OpAMD64TESTW_0(v *Value) bool { // match: (TESTW (MOVLconst [c]) x) // cond: // result: (TESTWconst [c] x) @@ -34641,7 +34853,7 @@ func rewriteValueAMD64_OpAMD64TESTW(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool { +func rewriteValueAMD64_OpAMD64XADDLlock_0(v *Value) bool { // match: (XADDLlock [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XADDLlock [off1+off2] {sym} val ptr mem) @@ -34669,7 +34881,7 @@ func rewriteValueAMD64_OpAMD64XADDLlock(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool { +func rewriteValueAMD64_OpAMD64XADDQlock_0(v *Value) bool { // match: (XADDQlock [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XADDQlock [off1+off2] {sym} val ptr mem) @@ -34697,7 +34909,7 @@ func rewriteValueAMD64_OpAMD64XADDQlock(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool { +func rewriteValueAMD64_OpAMD64XCHGL_0(v *Value) bool { // match: (XCHGL [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XCHGL [off1+off2] {sym} val ptr mem) @@ -34751,7 +34963,7 @@ func rewriteValueAMD64_OpAMD64XCHGL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64XCHGQ_0(v *Value) bool { // match: (XCHGQ [off1] {sym} val (ADDQconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (XCHGQ [off1+off2] {sym} val ptr mem) @@ -34805,7 +35017,7 @@ func rewriteValueAMD64_OpAMD64XCHGQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XORL(v *Value) bool { +func rewriteValueAMD64_OpAMD64XORL_0(v *Value) bool { // match: (XORL x (MOVLconst [c])) // cond: // result: (XORLconst [c] x) @@ -35032,6 +35244,9 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueAMD64_OpAMD64XORL_10(v *Value) bool { // match: (XORL l:(MOVLload [off] {sym} ptr mem) x) // cond: canMergeLoad(v, l, x) && clobber(l) // result: (XORLmem x [off] {sym} ptr mem) @@ -35058,7 +35273,7 @@ func rewriteValueAMD64_OpAMD64XORL(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64XORLconst_0(v *Value) bool { // match: (XORLconst [c] (XORLconst [d] x)) // cond: // result: (XORLconst [c ^ d] x) @@ -35105,7 +35320,7 @@ func rewriteValueAMD64_OpAMD64XORLconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool { +func rewriteValueAMD64_OpAMD64XORQ_0(v *Value) bool { // match: (XORQ x (MOVQconst [c])) // cond: is32Bit(c) // result: (XORQconst [c] x) @@ -35256,7 +35471,7 @@ func rewriteValueAMD64_OpAMD64XORQ(v *Value) bool { } return false } -func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool { +func rewriteValueAMD64_OpAMD64XORQconst_0(v *Value) bool { // match: (XORQconst [c] (XORQconst [d] x)) // cond: // result: (XORQconst [c ^ d] x) @@ -35302,7 +35517,7 @@ func rewriteValueAMD64_OpAMD64XORQconst(v *Value) bool { } return false } -func rewriteValueAMD64_OpAdd16(v *Value) bool { +func rewriteValueAMD64_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDL x y) @@ -35315,7 +35530,7 @@ func rewriteValueAMD64_OpAdd16(v *Value) bool { return true } } -func rewriteValueAMD64_OpAdd32(v *Value) bool { +func rewriteValueAMD64_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDL x y) @@ -35328,7 +35543,7 @@ func rewriteValueAMD64_OpAdd32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAdd32F(v *Value) bool { +func rewriteValueAMD64_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDSS x y) @@ -35341,7 +35556,7 @@ func rewriteValueAMD64_OpAdd32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpAdd64(v *Value) bool { +func rewriteValueAMD64_OpAdd64_0(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADDQ x y) @@ -35354,7 +35569,7 @@ func rewriteValueAMD64_OpAdd64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAdd64F(v *Value) bool { +func rewriteValueAMD64_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDSD x y) @@ -35367,7 +35582,7 @@ func rewriteValueAMD64_OpAdd64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpAdd8(v *Value) bool { +func rewriteValueAMD64_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDL x y) @@ -35380,7 +35595,7 @@ func rewriteValueAMD64_OpAdd8(v *Value) bool { return true } } -func rewriteValueAMD64_OpAddPtr(v *Value) bool { +func rewriteValueAMD64_OpAddPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -35415,7 +35630,7 @@ func rewriteValueAMD64_OpAddPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpAddr(v *Value) bool { +func rewriteValueAMD64_OpAddr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -35450,7 +35665,7 @@ func rewriteValueAMD64_OpAddr(v *Value) bool { } return false } -func rewriteValueAMD64_OpAnd16(v *Value) bool { +func rewriteValueAMD64_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDL x y) @@ -35463,7 +35678,7 @@ func rewriteValueAMD64_OpAnd16(v *Value) bool { return true } } -func rewriteValueAMD64_OpAnd32(v *Value) bool { +func rewriteValueAMD64_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDL x y) @@ -35476,7 +35691,7 @@ func rewriteValueAMD64_OpAnd32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAnd64(v *Value) bool { +func rewriteValueAMD64_OpAnd64_0(v *Value) bool { // match: (And64 x y) // cond: // result: (ANDQ x y) @@ -35489,7 +35704,7 @@ func rewriteValueAMD64_OpAnd64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAnd8(v *Value) bool { +func rewriteValueAMD64_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDL x y) @@ -35502,7 +35717,7 @@ func rewriteValueAMD64_OpAnd8(v *Value) bool { return true } } -func rewriteValueAMD64_OpAndB(v *Value) bool { +func rewriteValueAMD64_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDL x y) @@ -35515,7 +35730,7 @@ func rewriteValueAMD64_OpAndB(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool { +func rewriteValueAMD64_OpAtomicAdd32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35537,7 +35752,7 @@ func rewriteValueAMD64_OpAtomicAdd32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool { +func rewriteValueAMD64_OpAtomicAdd64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35559,7 +35774,7 @@ func rewriteValueAMD64_OpAtomicAdd64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool { +func rewriteValueAMD64_OpAtomicAnd8_0(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (ANDBlock ptr val mem) @@ -35574,7 +35789,7 @@ func rewriteValueAMD64_OpAtomicAnd8(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool { +func rewriteValueAMD64_OpAtomicCompareAndSwap32_0(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (CMPXCHGLlock ptr old new_ mem) @@ -35591,7 +35806,7 @@ func rewriteValueAMD64_OpAtomicCompareAndSwap32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool { +func rewriteValueAMD64_OpAtomicCompareAndSwap64_0(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (CMPXCHGQlock ptr old new_ mem) @@ -35608,7 +35823,7 @@ func rewriteValueAMD64_OpAtomicCompareAndSwap64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool { +func rewriteValueAMD64_OpAtomicExchange32_0(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (XCHGL val ptr mem) @@ -35623,7 +35838,7 @@ func rewriteValueAMD64_OpAtomicExchange32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool { +func rewriteValueAMD64_OpAtomicExchange64_0(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (XCHGQ val ptr mem) @@ -35638,7 +35853,7 @@ func rewriteValueAMD64_OpAtomicExchange64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool { +func rewriteValueAMD64_OpAtomicLoad32_0(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (MOVLatomicload ptr mem) @@ -35651,7 +35866,7 @@ func rewriteValueAMD64_OpAtomicLoad32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool { +func rewriteValueAMD64_OpAtomicLoad64_0(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (MOVQatomicload ptr mem) @@ -35664,7 +35879,7 @@ func rewriteValueAMD64_OpAtomicLoad64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool { +func rewriteValueAMD64_OpAtomicLoadPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -35699,7 +35914,7 @@ func rewriteValueAMD64_OpAtomicLoadPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpAtomicOr8(v *Value) bool { +func rewriteValueAMD64_OpAtomicOr8_0(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (ORBlock ptr val mem) @@ -35714,7 +35929,7 @@ func rewriteValueAMD64_OpAtomicOr8(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicStore32(v *Value) bool { +func rewriteValueAMD64_OpAtomicStore32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35735,7 +35950,7 @@ func rewriteValueAMD64_OpAtomicStore32(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicStore64(v *Value) bool { +func rewriteValueAMD64_OpAtomicStore64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35756,7 +35971,7 @@ func rewriteValueAMD64_OpAtomicStore64(v *Value) bool { return true } } -func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool { +func rewriteValueAMD64_OpAtomicStorePtrNoWB_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -35801,7 +36016,7 @@ func rewriteValueAMD64_OpAtomicStorePtrNoWB(v *Value) bool { } return false } -func rewriteValueAMD64_OpAvg64u(v *Value) bool { +func rewriteValueAMD64_OpAvg64u_0(v *Value) bool { // match: (Avg64u x y) // cond: // result: (AVGQU x y) @@ -35814,7 +36029,7 @@ func rewriteValueAMD64_OpAvg64u(v *Value) bool { return true } } -func rewriteValueAMD64_OpBitLen32(v *Value) bool { +func rewriteValueAMD64_OpBitLen32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35831,7 +36046,7 @@ func rewriteValueAMD64_OpBitLen32(v *Value) bool { return true } } -func rewriteValueAMD64_OpBitLen64(v *Value) bool { +func rewriteValueAMD64_OpBitLen64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -35862,7 +36077,7 @@ func rewriteValueAMD64_OpBitLen64(v *Value) bool { return true } } -func rewriteValueAMD64_OpBswap32(v *Value) bool { +func rewriteValueAMD64_OpBswap32_0(v *Value) bool { // match: (Bswap32 x) // cond: // result: (BSWAPL x) @@ -35873,7 +36088,7 @@ func rewriteValueAMD64_OpBswap32(v *Value) bool { return true } } -func rewriteValueAMD64_OpBswap64(v *Value) bool { +func rewriteValueAMD64_OpBswap64_0(v *Value) bool { // match: (Bswap64 x) // cond: // result: (BSWAPQ x) @@ -35884,7 +36099,7 @@ func rewriteValueAMD64_OpBswap64(v *Value) bool { return true } } -func rewriteValueAMD64_OpClosureCall(v *Value) bool { +func rewriteValueAMD64_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -35901,7 +36116,7 @@ func rewriteValueAMD64_OpClosureCall(v *Value) bool { return true } } -func rewriteValueAMD64_OpCom16(v *Value) bool { +func rewriteValueAMD64_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTL x) @@ -35912,7 +36127,7 @@ func rewriteValueAMD64_OpCom16(v *Value) bool { return true } } -func rewriteValueAMD64_OpCom32(v *Value) bool { +func rewriteValueAMD64_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTL x) @@ -35923,7 +36138,7 @@ func rewriteValueAMD64_OpCom32(v *Value) bool { return true } } -func rewriteValueAMD64_OpCom64(v *Value) bool { +func rewriteValueAMD64_OpCom64_0(v *Value) bool { // match: (Com64 x) // cond: // result: (NOTQ x) @@ -35934,7 +36149,7 @@ func rewriteValueAMD64_OpCom64(v *Value) bool { return true } } -func rewriteValueAMD64_OpCom8(v *Value) bool { +func rewriteValueAMD64_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTL x) @@ -35945,7 +36160,7 @@ func rewriteValueAMD64_OpCom8(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst16(v *Value) bool { +func rewriteValueAMD64_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVLconst [val]) @@ -35956,7 +36171,7 @@ func rewriteValueAMD64_OpConst16(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst32(v *Value) bool { +func rewriteValueAMD64_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVLconst [val]) @@ -35967,7 +36182,7 @@ func rewriteValueAMD64_OpConst32(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst32F(v *Value) bool { +func rewriteValueAMD64_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVSSconst [val]) @@ -35978,7 +36193,7 @@ func rewriteValueAMD64_OpConst32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst64(v *Value) bool { +func rewriteValueAMD64_OpConst64_0(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVQconst [val]) @@ -35989,7 +36204,7 @@ func rewriteValueAMD64_OpConst64(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst64F(v *Value) bool { +func rewriteValueAMD64_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVSDconst [val]) @@ -36000,7 +36215,7 @@ func rewriteValueAMD64_OpConst64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpConst8(v *Value) bool { +func rewriteValueAMD64_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVLconst [val]) @@ -36011,7 +36226,7 @@ func rewriteValueAMD64_OpConst8(v *Value) bool { return true } } -func rewriteValueAMD64_OpConstBool(v *Value) bool { +func rewriteValueAMD64_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVLconst [b]) @@ -36022,7 +36237,7 @@ func rewriteValueAMD64_OpConstBool(v *Value) bool { return true } } -func rewriteValueAMD64_OpConstNil(v *Value) bool { +func rewriteValueAMD64_OpConstNil_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -36051,7 +36266,7 @@ func rewriteValueAMD64_OpConstNil(v *Value) bool { } return false } -func rewriteValueAMD64_OpConvert(v *Value) bool { +func rewriteValueAMD64_OpConvert_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -36090,7 +36305,7 @@ func rewriteValueAMD64_OpConvert(v *Value) bool { } return false } -func rewriteValueAMD64_OpCtz32(v *Value) bool { +func rewriteValueAMD64_OpCtz32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36112,7 +36327,7 @@ func rewriteValueAMD64_OpCtz32(v *Value) bool { return true } } -func rewriteValueAMD64_OpCtz64(v *Value) bool { +func rewriteValueAMD64_OpCtz64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36140,7 +36355,7 @@ func rewriteValueAMD64_OpCtz64(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool { +func rewriteValueAMD64_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CVTTSS2SL x) @@ -36151,7 +36366,7 @@ func rewriteValueAMD64_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool { +func rewriteValueAMD64_OpCvt32Fto64_0(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (CVTTSS2SQ x) @@ -36162,7 +36377,7 @@ func rewriteValueAMD64_OpCvt32Fto64(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool { +func rewriteValueAMD64_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (CVTSS2SD x) @@ -36173,7 +36388,7 @@ func rewriteValueAMD64_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt32to32F(v *Value) bool { +func rewriteValueAMD64_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CVTSL2SS x) @@ -36184,7 +36399,7 @@ func rewriteValueAMD64_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt32to64F(v *Value) bool { +func rewriteValueAMD64_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CVTSL2SD x) @@ -36195,7 +36410,7 @@ func rewriteValueAMD64_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool { +func rewriteValueAMD64_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CVTTSD2SL x) @@ -36206,7 +36421,7 @@ func rewriteValueAMD64_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool { +func rewriteValueAMD64_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (CVTSD2SS x) @@ -36217,7 +36432,7 @@ func rewriteValueAMD64_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool { +func rewriteValueAMD64_OpCvt64Fto64_0(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (CVTTSD2SQ x) @@ -36228,7 +36443,7 @@ func rewriteValueAMD64_OpCvt64Fto64(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt64to32F(v *Value) bool { +func rewriteValueAMD64_OpCvt64to32F_0(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (CVTSQ2SS x) @@ -36239,7 +36454,7 @@ func rewriteValueAMD64_OpCvt64to32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpCvt64to64F(v *Value) bool { +func rewriteValueAMD64_OpCvt64to64F_0(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (CVTSQ2SD x) @@ -36250,7 +36465,7 @@ func rewriteValueAMD64_OpCvt64to64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv128u(v *Value) bool { +func rewriteValueAMD64_OpDiv128u_0(v *Value) bool { // match: (Div128u xhi xlo y) // cond: // result: (DIVQU2 xhi xlo y) @@ -36265,7 +36480,7 @@ func rewriteValueAMD64_OpDiv128u(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv16(v *Value) bool { +func rewriteValueAMD64_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36284,7 +36499,7 @@ func rewriteValueAMD64_OpDiv16(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv16u(v *Value) bool { +func rewriteValueAMD64_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36303,7 +36518,7 @@ func rewriteValueAMD64_OpDiv16u(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv32(v *Value) bool { +func rewriteValueAMD64_OpDiv32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36322,7 +36537,7 @@ func rewriteValueAMD64_OpDiv32(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv32F(v *Value) bool { +func rewriteValueAMD64_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVSS x y) @@ -36335,7 +36550,7 @@ func rewriteValueAMD64_OpDiv32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv32u(v *Value) bool { +func rewriteValueAMD64_OpDiv32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36354,7 +36569,7 @@ func rewriteValueAMD64_OpDiv32u(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv64(v *Value) bool { +func rewriteValueAMD64_OpDiv64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36373,7 +36588,7 @@ func rewriteValueAMD64_OpDiv64(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv64F(v *Value) bool { +func rewriteValueAMD64_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVSD x y) @@ -36386,7 +36601,7 @@ func rewriteValueAMD64_OpDiv64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv64u(v *Value) bool { +func rewriteValueAMD64_OpDiv64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36405,7 +36620,7 @@ func rewriteValueAMD64_OpDiv64u(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv8(v *Value) bool { +func rewriteValueAMD64_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36428,7 +36643,7 @@ func rewriteValueAMD64_OpDiv8(v *Value) bool { return true } } -func rewriteValueAMD64_OpDiv8u(v *Value) bool { +func rewriteValueAMD64_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -36451,7 +36666,7 @@ func rewriteValueAMD64_OpDiv8u(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq16(v *Value) bool { +func rewriteValueAMD64_OpEq16_0(v *Value) bool { b := v.Block _ = b // match: (Eq16 x y) @@ -36468,7 +36683,7 @@ func rewriteValueAMD64_OpEq16(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq32(v *Value) bool { +func rewriteValueAMD64_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -36485,7 +36700,7 @@ func rewriteValueAMD64_OpEq32(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq32F(v *Value) bool { +func rewriteValueAMD64_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -36502,7 +36717,7 @@ func rewriteValueAMD64_OpEq32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq64(v *Value) bool { +func rewriteValueAMD64_OpEq64_0(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -36519,7 +36734,7 @@ func rewriteValueAMD64_OpEq64(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq64F(v *Value) bool { +func rewriteValueAMD64_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -36536,7 +36751,7 @@ func rewriteValueAMD64_OpEq64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpEq8(v *Value) bool { +func rewriteValueAMD64_OpEq8_0(v *Value) bool { b := v.Block _ = b // match: (Eq8 x y) @@ -36553,7 +36768,7 @@ func rewriteValueAMD64_OpEq8(v *Value) bool { return true } } -func rewriteValueAMD64_OpEqB(v *Value) bool { +func rewriteValueAMD64_OpEqB_0(v *Value) bool { b := v.Block _ = b // match: (EqB x y) @@ -36570,7 +36785,7 @@ func rewriteValueAMD64_OpEqB(v *Value) bool { return true } } -func rewriteValueAMD64_OpEqPtr(v *Value) bool { +func rewriteValueAMD64_OpEqPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -36609,7 +36824,7 @@ func rewriteValueAMD64_OpEqPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpGeq16(v *Value) bool { +func rewriteValueAMD64_OpGeq16_0(v *Value) bool { b := v.Block _ = b // match: (Geq16 x y) @@ -36626,7 +36841,7 @@ func rewriteValueAMD64_OpGeq16(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq16U(v *Value) bool { +func rewriteValueAMD64_OpGeq16U_0(v *Value) bool { b := v.Block _ = b // match: (Geq16U x y) @@ -36643,7 +36858,7 @@ func rewriteValueAMD64_OpGeq16U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq32(v *Value) bool { +func rewriteValueAMD64_OpGeq32_0(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -36660,7 +36875,7 @@ func rewriteValueAMD64_OpGeq32(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq32F(v *Value) bool { +func rewriteValueAMD64_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -36677,7 +36892,7 @@ func rewriteValueAMD64_OpGeq32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq32U(v *Value) bool { +func rewriteValueAMD64_OpGeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -36694,7 +36909,7 @@ func rewriteValueAMD64_OpGeq32U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq64(v *Value) bool { +func rewriteValueAMD64_OpGeq64_0(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -36711,7 +36926,7 @@ func rewriteValueAMD64_OpGeq64(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq64F(v *Value) bool { +func rewriteValueAMD64_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -36728,7 +36943,7 @@ func rewriteValueAMD64_OpGeq64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq64U(v *Value) bool { +func rewriteValueAMD64_OpGeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -36745,7 +36960,7 @@ func rewriteValueAMD64_OpGeq64U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq8(v *Value) bool { +func rewriteValueAMD64_OpGeq8_0(v *Value) bool { b := v.Block _ = b // match: (Geq8 x y) @@ -36762,7 +36977,7 @@ func rewriteValueAMD64_OpGeq8(v *Value) bool { return true } } -func rewriteValueAMD64_OpGeq8U(v *Value) bool { +func rewriteValueAMD64_OpGeq8U_0(v *Value) bool { b := v.Block _ = b // match: (Geq8U x y) @@ -36779,7 +36994,7 @@ func rewriteValueAMD64_OpGeq8U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool { +func rewriteValueAMD64_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -36788,7 +37003,7 @@ func rewriteValueAMD64_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueAMD64_OpGetG(v *Value) bool { +func rewriteValueAMD64_OpGetG_0(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -36799,7 +37014,7 @@ func rewriteValueAMD64_OpGetG(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater16(v *Value) bool { +func rewriteValueAMD64_OpGreater16_0(v *Value) bool { b := v.Block _ = b // match: (Greater16 x y) @@ -36816,7 +37031,7 @@ func rewriteValueAMD64_OpGreater16(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater16U(v *Value) bool { +func rewriteValueAMD64_OpGreater16U_0(v *Value) bool { b := v.Block _ = b // match: (Greater16U x y) @@ -36833,7 +37048,7 @@ func rewriteValueAMD64_OpGreater16U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater32(v *Value) bool { +func rewriteValueAMD64_OpGreater32_0(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -36850,7 +37065,7 @@ func rewriteValueAMD64_OpGreater32(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater32F(v *Value) bool { +func rewriteValueAMD64_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -36867,7 +37082,7 @@ func rewriteValueAMD64_OpGreater32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater32U(v *Value) bool { +func rewriteValueAMD64_OpGreater32U_0(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -36884,7 +37099,7 @@ func rewriteValueAMD64_OpGreater32U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater64(v *Value) bool { +func rewriteValueAMD64_OpGreater64_0(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -36901,7 +37116,7 @@ func rewriteValueAMD64_OpGreater64(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater64F(v *Value) bool { +func rewriteValueAMD64_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -36918,7 +37133,7 @@ func rewriteValueAMD64_OpGreater64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater64U(v *Value) bool { +func rewriteValueAMD64_OpGreater64U_0(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -36935,7 +37150,7 @@ func rewriteValueAMD64_OpGreater64U(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater8(v *Value) bool { +func rewriteValueAMD64_OpGreater8_0(v *Value) bool { b := v.Block _ = b // match: (Greater8 x y) @@ -36952,7 +37167,7 @@ func rewriteValueAMD64_OpGreater8(v *Value) bool { return true } } -func rewriteValueAMD64_OpGreater8U(v *Value) bool { +func rewriteValueAMD64_OpGreater8U_0(v *Value) bool { b := v.Block _ = b // match: (Greater8U x y) @@ -36969,7 +37184,7 @@ func rewriteValueAMD64_OpGreater8U(v *Value) bool { return true } } -func rewriteValueAMD64_OpHmul32(v *Value) bool { +func rewriteValueAMD64_OpHmul32_0(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMULL x y) @@ -36982,7 +37197,7 @@ func rewriteValueAMD64_OpHmul32(v *Value) bool { return true } } -func rewriteValueAMD64_OpHmul32u(v *Value) bool { +func rewriteValueAMD64_OpHmul32u_0(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULLU x y) @@ -36995,7 +37210,7 @@ func rewriteValueAMD64_OpHmul32u(v *Value) bool { return true } } -func rewriteValueAMD64_OpHmul64(v *Value) bool { +func rewriteValueAMD64_OpHmul64_0(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (HMULQ x y) @@ -37008,7 +37223,7 @@ func rewriteValueAMD64_OpHmul64(v *Value) bool { return true } } -func rewriteValueAMD64_OpHmul64u(v *Value) bool { +func rewriteValueAMD64_OpHmul64u_0(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (HMULQU x y) @@ -37021,7 +37236,7 @@ func rewriteValueAMD64_OpHmul64u(v *Value) bool { return true } } -func rewriteValueAMD64_OpInt64Hi(v *Value) bool { +func rewriteValueAMD64_OpInt64Hi_0(v *Value) bool { // match: (Int64Hi x) // cond: // result: (SHRQconst [32] x) @@ -37033,7 +37248,7 @@ func rewriteValueAMD64_OpInt64Hi(v *Value) bool { return true } } -func rewriteValueAMD64_OpInterCall(v *Value) bool { +func rewriteValueAMD64_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -37048,7 +37263,7 @@ func rewriteValueAMD64_OpInterCall(v *Value) bool { return true } } -func rewriteValueAMD64_OpIsInBounds(v *Value) bool { +func rewriteValueAMD64_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -37065,7 +37280,7 @@ func rewriteValueAMD64_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueAMD64_OpIsNonNil(v *Value) bool { +func rewriteValueAMD64_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -37102,7 +37317,7 @@ func rewriteValueAMD64_OpIsNonNil(v *Value) bool { } return false } -func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool { +func rewriteValueAMD64_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -37119,7 +37334,7 @@ func rewriteValueAMD64_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq16(v *Value) bool { +func rewriteValueAMD64_OpLeq16_0(v *Value) bool { b := v.Block _ = b // match: (Leq16 x y) @@ -37136,7 +37351,7 @@ func rewriteValueAMD64_OpLeq16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq16U(v *Value) bool { +func rewriteValueAMD64_OpLeq16U_0(v *Value) bool { b := v.Block _ = b // match: (Leq16U x y) @@ -37153,7 +37368,7 @@ func rewriteValueAMD64_OpLeq16U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq32(v *Value) bool { +func rewriteValueAMD64_OpLeq32_0(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -37170,7 +37385,7 @@ func rewriteValueAMD64_OpLeq32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq32F(v *Value) bool { +func rewriteValueAMD64_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -37187,7 +37402,7 @@ func rewriteValueAMD64_OpLeq32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq32U(v *Value) bool { +func rewriteValueAMD64_OpLeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -37204,7 +37419,7 @@ func rewriteValueAMD64_OpLeq32U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq64(v *Value) bool { +func rewriteValueAMD64_OpLeq64_0(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -37221,7 +37436,7 @@ func rewriteValueAMD64_OpLeq64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq64F(v *Value) bool { +func rewriteValueAMD64_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -37238,7 +37453,7 @@ func rewriteValueAMD64_OpLeq64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq64U(v *Value) bool { +func rewriteValueAMD64_OpLeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -37255,7 +37470,7 @@ func rewriteValueAMD64_OpLeq64U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq8(v *Value) bool { +func rewriteValueAMD64_OpLeq8_0(v *Value) bool { b := v.Block _ = b // match: (Leq8 x y) @@ -37272,7 +37487,7 @@ func rewriteValueAMD64_OpLeq8(v *Value) bool { return true } } -func rewriteValueAMD64_OpLeq8U(v *Value) bool { +func rewriteValueAMD64_OpLeq8U_0(v *Value) bool { b := v.Block _ = b // match: (Leq8U x y) @@ -37289,7 +37504,7 @@ func rewriteValueAMD64_OpLeq8U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess16(v *Value) bool { +func rewriteValueAMD64_OpLess16_0(v *Value) bool { b := v.Block _ = b // match: (Less16 x y) @@ -37306,7 +37521,7 @@ func rewriteValueAMD64_OpLess16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess16U(v *Value) bool { +func rewriteValueAMD64_OpLess16U_0(v *Value) bool { b := v.Block _ = b // match: (Less16U x y) @@ -37323,7 +37538,7 @@ func rewriteValueAMD64_OpLess16U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess32(v *Value) bool { +func rewriteValueAMD64_OpLess32_0(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -37340,7 +37555,7 @@ func rewriteValueAMD64_OpLess32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess32F(v *Value) bool { +func rewriteValueAMD64_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -37357,7 +37572,7 @@ func rewriteValueAMD64_OpLess32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess32U(v *Value) bool { +func rewriteValueAMD64_OpLess32U_0(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -37374,7 +37589,7 @@ func rewriteValueAMD64_OpLess32U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess64(v *Value) bool { +func rewriteValueAMD64_OpLess64_0(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -37391,7 +37606,7 @@ func rewriteValueAMD64_OpLess64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess64F(v *Value) bool { +func rewriteValueAMD64_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -37408,7 +37623,7 @@ func rewriteValueAMD64_OpLess64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess64U(v *Value) bool { +func rewriteValueAMD64_OpLess64U_0(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -37425,7 +37640,7 @@ func rewriteValueAMD64_OpLess64U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess8(v *Value) bool { +func rewriteValueAMD64_OpLess8_0(v *Value) bool { b := v.Block _ = b // match: (Less8 x y) @@ -37442,7 +37657,7 @@ func rewriteValueAMD64_OpLess8(v *Value) bool { return true } } -func rewriteValueAMD64_OpLess8U(v *Value) bool { +func rewriteValueAMD64_OpLess8U_0(v *Value) bool { b := v.Block _ = b // match: (Less8U x y) @@ -37459,7 +37674,7 @@ func rewriteValueAMD64_OpLess8U(v *Value) bool { return true } } -func rewriteValueAMD64_OpLoad(v *Value) bool { +func rewriteValueAMD64_OpLoad_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -37556,7 +37771,7 @@ func rewriteValueAMD64_OpLoad(v *Value) bool { } return false } -func rewriteValueAMD64_OpLsh16x16(v *Value) bool { +func rewriteValueAMD64_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 x y) @@ -37580,7 +37795,7 @@ func rewriteValueAMD64_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh16x32(v *Value) bool { +func rewriteValueAMD64_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x y) @@ -37604,7 +37819,7 @@ func rewriteValueAMD64_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh16x64(v *Value) bool { +func rewriteValueAMD64_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 x y) @@ -37628,7 +37843,7 @@ func rewriteValueAMD64_OpLsh16x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh16x8(v *Value) bool { +func rewriteValueAMD64_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 x y) @@ -37652,7 +37867,7 @@ func rewriteValueAMD64_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh32x16(v *Value) bool { +func rewriteValueAMD64_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 x y) @@ -37676,7 +37891,7 @@ func rewriteValueAMD64_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh32x32(v *Value) bool { +func rewriteValueAMD64_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x y) @@ -37700,7 +37915,7 @@ func rewriteValueAMD64_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh32x64(v *Value) bool { +func rewriteValueAMD64_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 x y) @@ -37724,7 +37939,7 @@ func rewriteValueAMD64_OpLsh32x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh32x8(v *Value) bool { +func rewriteValueAMD64_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 x y) @@ -37748,7 +37963,7 @@ func rewriteValueAMD64_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh64x16(v *Value) bool { +func rewriteValueAMD64_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x16 x y) @@ -37772,7 +37987,7 @@ func rewriteValueAMD64_OpLsh64x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh64x32(v *Value) bool { +func rewriteValueAMD64_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 x y) @@ -37796,7 +38011,7 @@ func rewriteValueAMD64_OpLsh64x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh64x64(v *Value) bool { +func rewriteValueAMD64_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 x y) @@ -37820,7 +38035,7 @@ func rewriteValueAMD64_OpLsh64x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh64x8(v *Value) bool { +func rewriteValueAMD64_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x8 x y) @@ -37844,7 +38059,7 @@ func rewriteValueAMD64_OpLsh64x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh8x16(v *Value) bool { +func rewriteValueAMD64_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 x y) @@ -37868,7 +38083,7 @@ func rewriteValueAMD64_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh8x32(v *Value) bool { +func rewriteValueAMD64_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x y) @@ -37892,7 +38107,7 @@ func rewriteValueAMD64_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh8x64(v *Value) bool { +func rewriteValueAMD64_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 x y) @@ -37916,7 +38131,7 @@ func rewriteValueAMD64_OpLsh8x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpLsh8x8(v *Value) bool { +func rewriteValueAMD64_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 x y) @@ -37940,7 +38155,7 @@ func rewriteValueAMD64_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod16(v *Value) bool { +func rewriteValueAMD64_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -37959,7 +38174,7 @@ func rewriteValueAMD64_OpMod16(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod16u(v *Value) bool { +func rewriteValueAMD64_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -37978,7 +38193,7 @@ func rewriteValueAMD64_OpMod16u(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod32(v *Value) bool { +func rewriteValueAMD64_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -37997,7 +38212,7 @@ func rewriteValueAMD64_OpMod32(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod32u(v *Value) bool { +func rewriteValueAMD64_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38016,7 +38231,7 @@ func rewriteValueAMD64_OpMod32u(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod64(v *Value) bool { +func rewriteValueAMD64_OpMod64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38035,7 +38250,7 @@ func rewriteValueAMD64_OpMod64(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod64u(v *Value) bool { +func rewriteValueAMD64_OpMod64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38054,7 +38269,7 @@ func rewriteValueAMD64_OpMod64u(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod8(v *Value) bool { +func rewriteValueAMD64_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38077,7 +38292,7 @@ func rewriteValueAMD64_OpMod8(v *Value) bool { return true } } -func rewriteValueAMD64_OpMod8u(v *Value) bool { +func rewriteValueAMD64_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38100,11 +38315,9 @@ func rewriteValueAMD64_OpMod8u(v *Value) bool { return true } } -func rewriteValueAMD64_OpMove(v *Value) bool { +func rewriteValueAMD64_OpMove_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Move [0] _ _ mem) @@ -38327,6 +38540,15 @@ func rewriteValueAMD64_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueAMD64_OpMove_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Move [s] dst src mem) // cond: s > 8 && s < 16 // result: (MOVQstore [s-8] dst (MOVQload [s-8] src mem) (MOVQstore dst (MOVQload src mem) mem)) @@ -38458,7 +38680,7 @@ func rewriteValueAMD64_OpMove(v *Value) bool { } return false } -func rewriteValueAMD64_OpMul16(v *Value) bool { +func rewriteValueAMD64_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULL x y) @@ -38471,7 +38693,7 @@ func rewriteValueAMD64_OpMul16(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul32(v *Value) bool { +func rewriteValueAMD64_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULL x y) @@ -38484,7 +38706,7 @@ func rewriteValueAMD64_OpMul32(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul32F(v *Value) bool { +func rewriteValueAMD64_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULSS x y) @@ -38497,7 +38719,7 @@ func rewriteValueAMD64_OpMul32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul64(v *Value) bool { +func rewriteValueAMD64_OpMul64_0(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULQ x y) @@ -38510,7 +38732,7 @@ func rewriteValueAMD64_OpMul64(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul64F(v *Value) bool { +func rewriteValueAMD64_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULSD x y) @@ -38523,7 +38745,7 @@ func rewriteValueAMD64_OpMul64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul64uhilo(v *Value) bool { +func rewriteValueAMD64_OpMul64uhilo_0(v *Value) bool { // match: (Mul64uhilo x y) // cond: // result: (MULQU2 x y) @@ -38536,7 +38758,7 @@ func rewriteValueAMD64_OpMul64uhilo(v *Value) bool { return true } } -func rewriteValueAMD64_OpMul8(v *Value) bool { +func rewriteValueAMD64_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULL x y) @@ -38549,7 +38771,7 @@ func rewriteValueAMD64_OpMul8(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg16(v *Value) bool { +func rewriteValueAMD64_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGL x) @@ -38560,7 +38782,7 @@ func rewriteValueAMD64_OpNeg16(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg32(v *Value) bool { +func rewriteValueAMD64_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGL x) @@ -38571,7 +38793,7 @@ func rewriteValueAMD64_OpNeg32(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg32F(v *Value) bool { +func rewriteValueAMD64_OpNeg32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38589,7 +38811,7 @@ func rewriteValueAMD64_OpNeg32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg64(v *Value) bool { +func rewriteValueAMD64_OpNeg64_0(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEGQ x) @@ -38600,7 +38822,7 @@ func rewriteValueAMD64_OpNeg64(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg64F(v *Value) bool { +func rewriteValueAMD64_OpNeg64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38618,7 +38840,7 @@ func rewriteValueAMD64_OpNeg64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeg8(v *Value) bool { +func rewriteValueAMD64_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGL x) @@ -38629,7 +38851,7 @@ func rewriteValueAMD64_OpNeg8(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq16(v *Value) bool { +func rewriteValueAMD64_OpNeq16_0(v *Value) bool { b := v.Block _ = b // match: (Neq16 x y) @@ -38646,7 +38868,7 @@ func rewriteValueAMD64_OpNeq16(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq32(v *Value) bool { +func rewriteValueAMD64_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -38663,7 +38885,7 @@ func rewriteValueAMD64_OpNeq32(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq32F(v *Value) bool { +func rewriteValueAMD64_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -38680,7 +38902,7 @@ func rewriteValueAMD64_OpNeq32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq64(v *Value) bool { +func rewriteValueAMD64_OpNeq64_0(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -38697,7 +38919,7 @@ func rewriteValueAMD64_OpNeq64(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq64F(v *Value) bool { +func rewriteValueAMD64_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -38714,7 +38936,7 @@ func rewriteValueAMD64_OpNeq64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeq8(v *Value) bool { +func rewriteValueAMD64_OpNeq8_0(v *Value) bool { b := v.Block _ = b // match: (Neq8 x y) @@ -38731,7 +38953,7 @@ func rewriteValueAMD64_OpNeq8(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeqB(v *Value) bool { +func rewriteValueAMD64_OpNeqB_0(v *Value) bool { b := v.Block _ = b // match: (NeqB x y) @@ -38748,7 +38970,7 @@ func rewriteValueAMD64_OpNeqB(v *Value) bool { return true } } -func rewriteValueAMD64_OpNeqPtr(v *Value) bool { +func rewriteValueAMD64_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -38787,7 +39009,7 @@ func rewriteValueAMD64_OpNeqPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpNilCheck(v *Value) bool { +func rewriteValueAMD64_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -38800,7 +39022,7 @@ func rewriteValueAMD64_OpNilCheck(v *Value) bool { return true } } -func rewriteValueAMD64_OpNot(v *Value) bool { +func rewriteValueAMD64_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORLconst [1] x) @@ -38812,7 +39034,7 @@ func rewriteValueAMD64_OpNot(v *Value) bool { return true } } -func rewriteValueAMD64_OpOffPtr(v *Value) bool { +func rewriteValueAMD64_OpOffPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -38865,7 +39087,7 @@ func rewriteValueAMD64_OpOffPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpOr16(v *Value) bool { +func rewriteValueAMD64_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORL x y) @@ -38878,7 +39100,7 @@ func rewriteValueAMD64_OpOr16(v *Value) bool { return true } } -func rewriteValueAMD64_OpOr32(v *Value) bool { +func rewriteValueAMD64_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORL x y) @@ -38891,7 +39113,7 @@ func rewriteValueAMD64_OpOr32(v *Value) bool { return true } } -func rewriteValueAMD64_OpOr64(v *Value) bool { +func rewriteValueAMD64_OpOr64_0(v *Value) bool { // match: (Or64 x y) // cond: // result: (ORQ x y) @@ -38904,7 +39126,7 @@ func rewriteValueAMD64_OpOr64(v *Value) bool { return true } } -func rewriteValueAMD64_OpOr8(v *Value) bool { +func rewriteValueAMD64_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORL x y) @@ -38917,7 +39139,7 @@ func rewriteValueAMD64_OpOr8(v *Value) bool { return true } } -func rewriteValueAMD64_OpOrB(v *Value) bool { +func rewriteValueAMD64_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (ORL x y) @@ -38930,7 +39152,7 @@ func rewriteValueAMD64_OpOrB(v *Value) bool { return true } } -func rewriteValueAMD64_OpPopCount16(v *Value) bool { +func rewriteValueAMD64_OpPopCount16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38947,7 +39169,7 @@ func rewriteValueAMD64_OpPopCount16(v *Value) bool { return true } } -func rewriteValueAMD64_OpPopCount32(v *Value) bool { +func rewriteValueAMD64_OpPopCount32_0(v *Value) bool { // match: (PopCount32 x) // cond: // result: (POPCNTL x) @@ -38958,7 +39180,7 @@ func rewriteValueAMD64_OpPopCount32(v *Value) bool { return true } } -func rewriteValueAMD64_OpPopCount64(v *Value) bool { +func rewriteValueAMD64_OpPopCount64_0(v *Value) bool { // match: (PopCount64 x) // cond: // result: (POPCNTQ x) @@ -38969,7 +39191,7 @@ func rewriteValueAMD64_OpPopCount64(v *Value) bool { return true } } -func rewriteValueAMD64_OpPopCount8(v *Value) bool { +func rewriteValueAMD64_OpPopCount8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -38986,7 +39208,7 @@ func rewriteValueAMD64_OpPopCount8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRound32F(v *Value) bool { +func rewriteValueAMD64_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -38998,7 +39220,7 @@ func rewriteValueAMD64_OpRound32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpRound64F(v *Value) bool { +func rewriteValueAMD64_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -39010,7 +39232,7 @@ func rewriteValueAMD64_OpRound64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool { +func rewriteValueAMD64_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 x y) @@ -39034,7 +39256,7 @@ func rewriteValueAMD64_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool { +func rewriteValueAMD64_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 x y) @@ -39058,7 +39280,7 @@ func rewriteValueAMD64_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool { +func rewriteValueAMD64_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux64 x y) @@ -39082,7 +39304,7 @@ func rewriteValueAMD64_OpRsh16Ux64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool { +func rewriteValueAMD64_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 x y) @@ -39106,7 +39328,7 @@ func rewriteValueAMD64_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16x16(v *Value) bool { +func rewriteValueAMD64_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 x y) @@ -39133,7 +39355,7 @@ func rewriteValueAMD64_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16x32(v *Value) bool { +func rewriteValueAMD64_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 x y) @@ -39160,7 +39382,7 @@ func rewriteValueAMD64_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16x64(v *Value) bool { +func rewriteValueAMD64_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x64 x y) @@ -39187,7 +39409,7 @@ func rewriteValueAMD64_OpRsh16x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh16x8(v *Value) bool { +func rewriteValueAMD64_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 x y) @@ -39214,7 +39436,7 @@ func rewriteValueAMD64_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool { +func rewriteValueAMD64_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 x y) @@ -39238,7 +39460,7 @@ func rewriteValueAMD64_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool { +func rewriteValueAMD64_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x y) @@ -39262,7 +39484,7 @@ func rewriteValueAMD64_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool { +func rewriteValueAMD64_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux64 x y) @@ -39286,7 +39508,7 @@ func rewriteValueAMD64_OpRsh32Ux64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool { +func rewriteValueAMD64_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 x y) @@ -39310,7 +39532,7 @@ func rewriteValueAMD64_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32x16(v *Value) bool { +func rewriteValueAMD64_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 x y) @@ -39337,7 +39559,7 @@ func rewriteValueAMD64_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32x32(v *Value) bool { +func rewriteValueAMD64_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x y) @@ -39364,7 +39586,7 @@ func rewriteValueAMD64_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32x64(v *Value) bool { +func rewriteValueAMD64_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x64 x y) @@ -39391,7 +39613,7 @@ func rewriteValueAMD64_OpRsh32x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh32x8(v *Value) bool { +func rewriteValueAMD64_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 x y) @@ -39418,7 +39640,7 @@ func rewriteValueAMD64_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool { +func rewriteValueAMD64_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux16 x y) @@ -39442,7 +39664,7 @@ func rewriteValueAMD64_OpRsh64Ux16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool { +func rewriteValueAMD64_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 x y) @@ -39466,7 +39688,7 @@ func rewriteValueAMD64_OpRsh64Ux32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool { +func rewriteValueAMD64_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 x y) @@ -39490,7 +39712,7 @@ func rewriteValueAMD64_OpRsh64Ux64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool { +func rewriteValueAMD64_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux8 x y) @@ -39514,7 +39736,7 @@ func rewriteValueAMD64_OpRsh64Ux8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64x16(v *Value) bool { +func rewriteValueAMD64_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x16 x y) @@ -39541,7 +39763,7 @@ func rewriteValueAMD64_OpRsh64x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64x32(v *Value) bool { +func rewriteValueAMD64_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 x y) @@ -39568,7 +39790,7 @@ func rewriteValueAMD64_OpRsh64x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64x64(v *Value) bool { +func rewriteValueAMD64_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 x y) @@ -39595,7 +39817,7 @@ func rewriteValueAMD64_OpRsh64x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh64x8(v *Value) bool { +func rewriteValueAMD64_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x8 x y) @@ -39622,7 +39844,7 @@ func rewriteValueAMD64_OpRsh64x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool { +func rewriteValueAMD64_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 x y) @@ -39646,7 +39868,7 @@ func rewriteValueAMD64_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool { +func rewriteValueAMD64_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 x y) @@ -39670,7 +39892,7 @@ func rewriteValueAMD64_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool { +func rewriteValueAMD64_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux64 x y) @@ -39694,7 +39916,7 @@ func rewriteValueAMD64_OpRsh8Ux64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool { +func rewriteValueAMD64_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 x y) @@ -39718,7 +39940,7 @@ func rewriteValueAMD64_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8x16(v *Value) bool { +func rewriteValueAMD64_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 x y) @@ -39745,7 +39967,7 @@ func rewriteValueAMD64_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8x32(v *Value) bool { +func rewriteValueAMD64_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 x y) @@ -39772,7 +39994,7 @@ func rewriteValueAMD64_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8x64(v *Value) bool { +func rewriteValueAMD64_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x64 x y) @@ -39799,7 +40021,7 @@ func rewriteValueAMD64_OpRsh8x64(v *Value) bool { return true } } -func rewriteValueAMD64_OpRsh8x8(v *Value) bool { +func rewriteValueAMD64_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 x y) @@ -39826,7 +40048,7 @@ func rewriteValueAMD64_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueAMD64_OpSelect0(v *Value) bool { +func rewriteValueAMD64_OpSelect0_0(v *Value) bool { b := v.Block _ = b // match: (Select0 (AddTupleFirst32 tuple val)) @@ -39867,7 +40089,7 @@ func rewriteValueAMD64_OpSelect0(v *Value) bool { } return false } -func rewriteValueAMD64_OpSelect1(v *Value) bool { +func rewriteValueAMD64_OpSelect1_0(v *Value) bool { // match: (Select1 (AddTupleFirst32 tuple _)) // cond: // result: (Select1 tuple) @@ -39896,7 +40118,7 @@ func rewriteValueAMD64_OpSelect1(v *Value) bool { } return false } -func rewriteValueAMD64_OpSignExt16to32(v *Value) bool { +func rewriteValueAMD64_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVWQSX x) @@ -39907,7 +40129,7 @@ func rewriteValueAMD64_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueAMD64_OpSignExt16to64(v *Value) bool { +func rewriteValueAMD64_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVWQSX x) @@ -39918,7 +40140,7 @@ func rewriteValueAMD64_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValueAMD64_OpSignExt32to64(v *Value) bool { +func rewriteValueAMD64_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVLQSX x) @@ -39929,7 +40151,7 @@ func rewriteValueAMD64_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValueAMD64_OpSignExt8to16(v *Value) bool { +func rewriteValueAMD64_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBQSX x) @@ -39940,7 +40162,7 @@ func rewriteValueAMD64_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueAMD64_OpSignExt8to32(v *Value) bool { +func rewriteValueAMD64_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBQSX x) @@ -39951,7 +40173,7 @@ func rewriteValueAMD64_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueAMD64_OpSignExt8to64(v *Value) bool { +func rewriteValueAMD64_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBQSX x) @@ -39962,7 +40184,7 @@ func rewriteValueAMD64_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValueAMD64_OpSlicemask(v *Value) bool { +func rewriteValueAMD64_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -39979,7 +40201,7 @@ func rewriteValueAMD64_OpSlicemask(v *Value) bool { return true } } -func rewriteValueAMD64_OpSqrt(v *Value) bool { +func rewriteValueAMD64_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTSD x) @@ -39990,7 +40212,7 @@ func rewriteValueAMD64_OpSqrt(v *Value) bool { return true } } -func rewriteValueAMD64_OpStaticCall(v *Value) bool { +func rewriteValueAMD64_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -40005,7 +40227,7 @@ func rewriteValueAMD64_OpStaticCall(v *Value) bool { return true } } -func rewriteValueAMD64_OpStore(v *Value) bool { +func rewriteValueAMD64_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (MOVSDstore ptr val mem) @@ -40110,7 +40332,7 @@ func rewriteValueAMD64_OpStore(v *Value) bool { } return false } -func rewriteValueAMD64_OpSub16(v *Value) bool { +func rewriteValueAMD64_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBL x y) @@ -40123,7 +40345,7 @@ func rewriteValueAMD64_OpSub16(v *Value) bool { return true } } -func rewriteValueAMD64_OpSub32(v *Value) bool { +func rewriteValueAMD64_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBL x y) @@ -40136,7 +40358,7 @@ func rewriteValueAMD64_OpSub32(v *Value) bool { return true } } -func rewriteValueAMD64_OpSub32F(v *Value) bool { +func rewriteValueAMD64_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBSS x y) @@ -40149,7 +40371,7 @@ func rewriteValueAMD64_OpSub32F(v *Value) bool { return true } } -func rewriteValueAMD64_OpSub64(v *Value) bool { +func rewriteValueAMD64_OpSub64_0(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUBQ x y) @@ -40162,7 +40384,7 @@ func rewriteValueAMD64_OpSub64(v *Value) bool { return true } } -func rewriteValueAMD64_OpSub64F(v *Value) bool { +func rewriteValueAMD64_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBSD x y) @@ -40175,7 +40397,7 @@ func rewriteValueAMD64_OpSub64F(v *Value) bool { return true } } -func rewriteValueAMD64_OpSub8(v *Value) bool { +func rewriteValueAMD64_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBL x y) @@ -40188,7 +40410,7 @@ func rewriteValueAMD64_OpSub8(v *Value) bool { return true } } -func rewriteValueAMD64_OpSubPtr(v *Value) bool { +func rewriteValueAMD64_OpSubPtr_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -40223,7 +40445,7 @@ func rewriteValueAMD64_OpSubPtr(v *Value) bool { } return false } -func rewriteValueAMD64_OpTrunc16to8(v *Value) bool { +func rewriteValueAMD64_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -40235,7 +40457,7 @@ func rewriteValueAMD64_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueAMD64_OpTrunc32to16(v *Value) bool { +func rewriteValueAMD64_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -40247,7 +40469,7 @@ func rewriteValueAMD64_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueAMD64_OpTrunc32to8(v *Value) bool { +func rewriteValueAMD64_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -40259,7 +40481,7 @@ func rewriteValueAMD64_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueAMD64_OpTrunc64to16(v *Value) bool { +func rewriteValueAMD64_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -40271,7 +40493,7 @@ func rewriteValueAMD64_OpTrunc64to16(v *Value) bool { return true } } -func rewriteValueAMD64_OpTrunc64to32(v *Value) bool { +func rewriteValueAMD64_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -40283,7 +40505,7 @@ func rewriteValueAMD64_OpTrunc64to32(v *Value) bool { return true } } -func rewriteValueAMD64_OpTrunc64to8(v *Value) bool { +func rewriteValueAMD64_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -40295,7 +40517,7 @@ func rewriteValueAMD64_OpTrunc64to8(v *Value) bool { return true } } -func rewriteValueAMD64_OpXor16(v *Value) bool { +func rewriteValueAMD64_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORL x y) @@ -40308,7 +40530,7 @@ func rewriteValueAMD64_OpXor16(v *Value) bool { return true } } -func rewriteValueAMD64_OpXor32(v *Value) bool { +func rewriteValueAMD64_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORL x y) @@ -40321,7 +40543,7 @@ func rewriteValueAMD64_OpXor32(v *Value) bool { return true } } -func rewriteValueAMD64_OpXor64(v *Value) bool { +func rewriteValueAMD64_OpXor64_0(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XORQ x y) @@ -40334,7 +40556,7 @@ func rewriteValueAMD64_OpXor64(v *Value) bool { return true } } -func rewriteValueAMD64_OpXor8(v *Value) bool { +func rewriteValueAMD64_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORL x y) @@ -40347,13 +40569,9 @@ func rewriteValueAMD64_OpXor8(v *Value) bool { return true } } -func rewriteValueAMD64_OpZero(v *Value) bool { +func rewriteValueAMD64_OpZero_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config - types := &b.Func.Config.Types - _ = types // match: (Zero [0] _ mem) // cond: // result: mem @@ -40526,6 +40744,15 @@ func rewriteValueAMD64_OpZero(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueAMD64_OpZero_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Zero [16] destptr mem) // cond: // result: (MOVQstoreconst [makeValAndOff(0,8)] destptr (MOVQstoreconst [0] destptr mem)) @@ -40662,7 +40889,7 @@ func rewriteValueAMD64_OpZero(v *Value) bool { } return false } -func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool { +func rewriteValueAMD64_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVWQZX x) @@ -40673,7 +40900,7 @@ func rewriteValueAMD64_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool { +func rewriteValueAMD64_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVWQZX x) @@ -40684,7 +40911,7 @@ func rewriteValueAMD64_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool { +func rewriteValueAMD64_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVLQZX x) @@ -40695,7 +40922,7 @@ func rewriteValueAMD64_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool { +func rewriteValueAMD64_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBQZX x) @@ -40706,7 +40933,7 @@ func rewriteValueAMD64_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool { +func rewriteValueAMD64_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBQZX x) @@ -40717,7 +40944,7 @@ func rewriteValueAMD64_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueAMD64_OpZeroExt8to64(v *Value) bool { +func rewriteValueAMD64_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBQZX x) diff --git a/src/cmd/compile/internal/ssa/rewriteARM.go b/src/cmd/compile/internal/ssa/rewriteARM.go index 944093a716..1176969310 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM.go +++ b/src/cmd/compile/internal/ssa/rewriteARM.go @@ -14,721 +14,721 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueARM(v *Value) bool { switch v.Op { case OpARMADC: - return rewriteValueARM_OpARMADC(v) + return rewriteValueARM_OpARMADC_0(v) || rewriteValueARM_OpARMADC_10(v) || rewriteValueARM_OpARMADC_20(v) case OpARMADCconst: - return rewriteValueARM_OpARMADCconst(v) + return rewriteValueARM_OpARMADCconst_0(v) case OpARMADCshiftLL: - return rewriteValueARM_OpARMADCshiftLL(v) + return rewriteValueARM_OpARMADCshiftLL_0(v) case OpARMADCshiftLLreg: - return rewriteValueARM_OpARMADCshiftLLreg(v) + return rewriteValueARM_OpARMADCshiftLLreg_0(v) case OpARMADCshiftRA: - return rewriteValueARM_OpARMADCshiftRA(v) + return rewriteValueARM_OpARMADCshiftRA_0(v) case OpARMADCshiftRAreg: - return rewriteValueARM_OpARMADCshiftRAreg(v) + return rewriteValueARM_OpARMADCshiftRAreg_0(v) case OpARMADCshiftRL: - return rewriteValueARM_OpARMADCshiftRL(v) + return rewriteValueARM_OpARMADCshiftRL_0(v) case OpARMADCshiftRLreg: - return rewriteValueARM_OpARMADCshiftRLreg(v) + return rewriteValueARM_OpARMADCshiftRLreg_0(v) case OpARMADD: - return rewriteValueARM_OpARMADD(v) + return rewriteValueARM_OpARMADD_0(v) || rewriteValueARM_OpARMADD_10(v) case OpARMADDS: - return rewriteValueARM_OpARMADDS(v) + return rewriteValueARM_OpARMADDS_0(v) || rewriteValueARM_OpARMADDS_10(v) case OpARMADDSshiftLL: - return rewriteValueARM_OpARMADDSshiftLL(v) + return rewriteValueARM_OpARMADDSshiftLL_0(v) case OpARMADDSshiftLLreg: - return rewriteValueARM_OpARMADDSshiftLLreg(v) + return rewriteValueARM_OpARMADDSshiftLLreg_0(v) case OpARMADDSshiftRA: - return rewriteValueARM_OpARMADDSshiftRA(v) + return rewriteValueARM_OpARMADDSshiftRA_0(v) case OpARMADDSshiftRAreg: - return rewriteValueARM_OpARMADDSshiftRAreg(v) + return rewriteValueARM_OpARMADDSshiftRAreg_0(v) case OpARMADDSshiftRL: - return rewriteValueARM_OpARMADDSshiftRL(v) + return rewriteValueARM_OpARMADDSshiftRL_0(v) case OpARMADDSshiftRLreg: - return rewriteValueARM_OpARMADDSshiftRLreg(v) + return rewriteValueARM_OpARMADDSshiftRLreg_0(v) case OpARMADDconst: - return rewriteValueARM_OpARMADDconst(v) + return rewriteValueARM_OpARMADDconst_0(v) case OpARMADDshiftLL: - return rewriteValueARM_OpARMADDshiftLL(v) + return rewriteValueARM_OpARMADDshiftLL_0(v) case OpARMADDshiftLLreg: - return rewriteValueARM_OpARMADDshiftLLreg(v) + return rewriteValueARM_OpARMADDshiftLLreg_0(v) case OpARMADDshiftRA: - return rewriteValueARM_OpARMADDshiftRA(v) + return rewriteValueARM_OpARMADDshiftRA_0(v) case OpARMADDshiftRAreg: - return rewriteValueARM_OpARMADDshiftRAreg(v) + return rewriteValueARM_OpARMADDshiftRAreg_0(v) case OpARMADDshiftRL: - return rewriteValueARM_OpARMADDshiftRL(v) + return rewriteValueARM_OpARMADDshiftRL_0(v) case OpARMADDshiftRLreg: - return rewriteValueARM_OpARMADDshiftRLreg(v) + return rewriteValueARM_OpARMADDshiftRLreg_0(v) case OpARMAND: - return rewriteValueARM_OpARMAND(v) + return rewriteValueARM_OpARMAND_0(v) || rewriteValueARM_OpARMAND_10(v) || rewriteValueARM_OpARMAND_20(v) case OpARMANDconst: - return rewriteValueARM_OpARMANDconst(v) + return rewriteValueARM_OpARMANDconst_0(v) case OpARMANDshiftLL: - return rewriteValueARM_OpARMANDshiftLL(v) + return rewriteValueARM_OpARMANDshiftLL_0(v) case OpARMANDshiftLLreg: - return rewriteValueARM_OpARMANDshiftLLreg(v) + return rewriteValueARM_OpARMANDshiftLLreg_0(v) case OpARMANDshiftRA: - return rewriteValueARM_OpARMANDshiftRA(v) + return rewriteValueARM_OpARMANDshiftRA_0(v) case OpARMANDshiftRAreg: - return rewriteValueARM_OpARMANDshiftRAreg(v) + return rewriteValueARM_OpARMANDshiftRAreg_0(v) case OpARMANDshiftRL: - return rewriteValueARM_OpARMANDshiftRL(v) + return rewriteValueARM_OpARMANDshiftRL_0(v) case OpARMANDshiftRLreg: - return rewriteValueARM_OpARMANDshiftRLreg(v) + return rewriteValueARM_OpARMANDshiftRLreg_0(v) case OpARMBIC: - return rewriteValueARM_OpARMBIC(v) + return rewriteValueARM_OpARMBIC_0(v) case OpARMBICconst: - return rewriteValueARM_OpARMBICconst(v) + return rewriteValueARM_OpARMBICconst_0(v) case OpARMBICshiftLL: - return rewriteValueARM_OpARMBICshiftLL(v) + return rewriteValueARM_OpARMBICshiftLL_0(v) case OpARMBICshiftLLreg: - return rewriteValueARM_OpARMBICshiftLLreg(v) + return rewriteValueARM_OpARMBICshiftLLreg_0(v) case OpARMBICshiftRA: - return rewriteValueARM_OpARMBICshiftRA(v) + return rewriteValueARM_OpARMBICshiftRA_0(v) case OpARMBICshiftRAreg: - return rewriteValueARM_OpARMBICshiftRAreg(v) + return rewriteValueARM_OpARMBICshiftRAreg_0(v) case OpARMBICshiftRL: - return rewriteValueARM_OpARMBICshiftRL(v) + return rewriteValueARM_OpARMBICshiftRL_0(v) case OpARMBICshiftRLreg: - return rewriteValueARM_OpARMBICshiftRLreg(v) + return rewriteValueARM_OpARMBICshiftRLreg_0(v) case OpARMCMOVWHSconst: - return rewriteValueARM_OpARMCMOVWHSconst(v) + return rewriteValueARM_OpARMCMOVWHSconst_0(v) case OpARMCMOVWLSconst: - return rewriteValueARM_OpARMCMOVWLSconst(v) + return rewriteValueARM_OpARMCMOVWLSconst_0(v) case OpARMCMP: - return rewriteValueARM_OpARMCMP(v) + return rewriteValueARM_OpARMCMP_0(v) || rewriteValueARM_OpARMCMP_10(v) case OpARMCMPD: - return rewriteValueARM_OpARMCMPD(v) + return rewriteValueARM_OpARMCMPD_0(v) case OpARMCMPF: - return rewriteValueARM_OpARMCMPF(v) + return rewriteValueARM_OpARMCMPF_0(v) case OpARMCMPconst: - return rewriteValueARM_OpARMCMPconst(v) + return rewriteValueARM_OpARMCMPconst_0(v) case OpARMCMPshiftLL: - return rewriteValueARM_OpARMCMPshiftLL(v) + return rewriteValueARM_OpARMCMPshiftLL_0(v) case OpARMCMPshiftLLreg: - return rewriteValueARM_OpARMCMPshiftLLreg(v) + return rewriteValueARM_OpARMCMPshiftLLreg_0(v) case OpARMCMPshiftRA: - return rewriteValueARM_OpARMCMPshiftRA(v) + return rewriteValueARM_OpARMCMPshiftRA_0(v) case OpARMCMPshiftRAreg: - return rewriteValueARM_OpARMCMPshiftRAreg(v) + return rewriteValueARM_OpARMCMPshiftRAreg_0(v) case OpARMCMPshiftRL: - return rewriteValueARM_OpARMCMPshiftRL(v) + return rewriteValueARM_OpARMCMPshiftRL_0(v) case OpARMCMPshiftRLreg: - return rewriteValueARM_OpARMCMPshiftRLreg(v) + return rewriteValueARM_OpARMCMPshiftRLreg_0(v) case OpARMEqual: - return rewriteValueARM_OpARMEqual(v) + return rewriteValueARM_OpARMEqual_0(v) case OpARMGreaterEqual: - return rewriteValueARM_OpARMGreaterEqual(v) + return rewriteValueARM_OpARMGreaterEqual_0(v) case OpARMGreaterEqualU: - return rewriteValueARM_OpARMGreaterEqualU(v) + return rewriteValueARM_OpARMGreaterEqualU_0(v) case OpARMGreaterThan: - return rewriteValueARM_OpARMGreaterThan(v) + return rewriteValueARM_OpARMGreaterThan_0(v) case OpARMGreaterThanU: - return rewriteValueARM_OpARMGreaterThanU(v) + return rewriteValueARM_OpARMGreaterThanU_0(v) case OpARMLessEqual: - return rewriteValueARM_OpARMLessEqual(v) + return rewriteValueARM_OpARMLessEqual_0(v) case OpARMLessEqualU: - return rewriteValueARM_OpARMLessEqualU(v) + return rewriteValueARM_OpARMLessEqualU_0(v) case OpARMLessThan: - return rewriteValueARM_OpARMLessThan(v) + return rewriteValueARM_OpARMLessThan_0(v) case OpARMLessThanU: - return rewriteValueARM_OpARMLessThanU(v) + return rewriteValueARM_OpARMLessThanU_0(v) case OpARMMOVBUload: - return rewriteValueARM_OpARMMOVBUload(v) + return rewriteValueARM_OpARMMOVBUload_0(v) case OpARMMOVBUreg: - return rewriteValueARM_OpARMMOVBUreg(v) + return rewriteValueARM_OpARMMOVBUreg_0(v) case OpARMMOVBload: - return rewriteValueARM_OpARMMOVBload(v) + return rewriteValueARM_OpARMMOVBload_0(v) case OpARMMOVBreg: - return rewriteValueARM_OpARMMOVBreg(v) + return rewriteValueARM_OpARMMOVBreg_0(v) case OpARMMOVBstore: - return rewriteValueARM_OpARMMOVBstore(v) + return rewriteValueARM_OpARMMOVBstore_0(v) case OpARMMOVDload: - return rewriteValueARM_OpARMMOVDload(v) + return rewriteValueARM_OpARMMOVDload_0(v) case OpARMMOVDstore: - return rewriteValueARM_OpARMMOVDstore(v) + return rewriteValueARM_OpARMMOVDstore_0(v) case OpARMMOVFload: - return rewriteValueARM_OpARMMOVFload(v) + return rewriteValueARM_OpARMMOVFload_0(v) case OpARMMOVFstore: - return rewriteValueARM_OpARMMOVFstore(v) + return rewriteValueARM_OpARMMOVFstore_0(v) case OpARMMOVHUload: - return rewriteValueARM_OpARMMOVHUload(v) + return rewriteValueARM_OpARMMOVHUload_0(v) case OpARMMOVHUreg: - return rewriteValueARM_OpARMMOVHUreg(v) + return rewriteValueARM_OpARMMOVHUreg_0(v) case OpARMMOVHload: - return rewriteValueARM_OpARMMOVHload(v) + return rewriteValueARM_OpARMMOVHload_0(v) case OpARMMOVHreg: - return rewriteValueARM_OpARMMOVHreg(v) + return rewriteValueARM_OpARMMOVHreg_0(v) case OpARMMOVHstore: - return rewriteValueARM_OpARMMOVHstore(v) + return rewriteValueARM_OpARMMOVHstore_0(v) case OpARMMOVWload: - return rewriteValueARM_OpARMMOVWload(v) + return rewriteValueARM_OpARMMOVWload_0(v) case OpARMMOVWloadidx: - return rewriteValueARM_OpARMMOVWloadidx(v) + return rewriteValueARM_OpARMMOVWloadidx_0(v) case OpARMMOVWloadshiftLL: - return rewriteValueARM_OpARMMOVWloadshiftLL(v) + return rewriteValueARM_OpARMMOVWloadshiftLL_0(v) case OpARMMOVWloadshiftRA: - return rewriteValueARM_OpARMMOVWloadshiftRA(v) + return rewriteValueARM_OpARMMOVWloadshiftRA_0(v) case OpARMMOVWloadshiftRL: - return rewriteValueARM_OpARMMOVWloadshiftRL(v) + return rewriteValueARM_OpARMMOVWloadshiftRL_0(v) case OpARMMOVWreg: - return rewriteValueARM_OpARMMOVWreg(v) + return rewriteValueARM_OpARMMOVWreg_0(v) case OpARMMOVWstore: - return rewriteValueARM_OpARMMOVWstore(v) + return rewriteValueARM_OpARMMOVWstore_0(v) case OpARMMOVWstoreidx: - return rewriteValueARM_OpARMMOVWstoreidx(v) + return rewriteValueARM_OpARMMOVWstoreidx_0(v) case OpARMMOVWstoreshiftLL: - return rewriteValueARM_OpARMMOVWstoreshiftLL(v) + return rewriteValueARM_OpARMMOVWstoreshiftLL_0(v) case OpARMMOVWstoreshiftRA: - return rewriteValueARM_OpARMMOVWstoreshiftRA(v) + return rewriteValueARM_OpARMMOVWstoreshiftRA_0(v) case OpARMMOVWstoreshiftRL: - return rewriteValueARM_OpARMMOVWstoreshiftRL(v) + return rewriteValueARM_OpARMMOVWstoreshiftRL_0(v) case OpARMMUL: - return rewriteValueARM_OpARMMUL(v) + return rewriteValueARM_OpARMMUL_0(v) || rewriteValueARM_OpARMMUL_10(v) || rewriteValueARM_OpARMMUL_20(v) case OpARMMULA: - return rewriteValueARM_OpARMMULA(v) + return rewriteValueARM_OpARMMULA_0(v) || rewriteValueARM_OpARMMULA_10(v) || rewriteValueARM_OpARMMULA_20(v) case OpARMMVN: - return rewriteValueARM_OpARMMVN(v) + return rewriteValueARM_OpARMMVN_0(v) case OpARMMVNshiftLL: - return rewriteValueARM_OpARMMVNshiftLL(v) + return rewriteValueARM_OpARMMVNshiftLL_0(v) case OpARMMVNshiftLLreg: - return rewriteValueARM_OpARMMVNshiftLLreg(v) + return rewriteValueARM_OpARMMVNshiftLLreg_0(v) case OpARMMVNshiftRA: - return rewriteValueARM_OpARMMVNshiftRA(v) + return rewriteValueARM_OpARMMVNshiftRA_0(v) case OpARMMVNshiftRAreg: - return rewriteValueARM_OpARMMVNshiftRAreg(v) + return rewriteValueARM_OpARMMVNshiftRAreg_0(v) case OpARMMVNshiftRL: - return rewriteValueARM_OpARMMVNshiftRL(v) + return rewriteValueARM_OpARMMVNshiftRL_0(v) case OpARMMVNshiftRLreg: - return rewriteValueARM_OpARMMVNshiftRLreg(v) + return rewriteValueARM_OpARMMVNshiftRLreg_0(v) case OpARMNotEqual: - return rewriteValueARM_OpARMNotEqual(v) + return rewriteValueARM_OpARMNotEqual_0(v) case OpARMOR: - return rewriteValueARM_OpARMOR(v) + return rewriteValueARM_OpARMOR_0(v) || rewriteValueARM_OpARMOR_10(v) case OpARMORconst: - return rewriteValueARM_OpARMORconst(v) + return rewriteValueARM_OpARMORconst_0(v) case OpARMORshiftLL: - return rewriteValueARM_OpARMORshiftLL(v) + return rewriteValueARM_OpARMORshiftLL_0(v) case OpARMORshiftLLreg: - return rewriteValueARM_OpARMORshiftLLreg(v) + return rewriteValueARM_OpARMORshiftLLreg_0(v) case OpARMORshiftRA: - return rewriteValueARM_OpARMORshiftRA(v) + return rewriteValueARM_OpARMORshiftRA_0(v) case OpARMORshiftRAreg: - return rewriteValueARM_OpARMORshiftRAreg(v) + return rewriteValueARM_OpARMORshiftRAreg_0(v) case OpARMORshiftRL: - return rewriteValueARM_OpARMORshiftRL(v) + return rewriteValueARM_OpARMORshiftRL_0(v) case OpARMORshiftRLreg: - return rewriteValueARM_OpARMORshiftRLreg(v) + return rewriteValueARM_OpARMORshiftRLreg_0(v) case OpARMRSB: - return rewriteValueARM_OpARMRSB(v) + return rewriteValueARM_OpARMRSB_0(v) || rewriteValueARM_OpARMRSB_10(v) case OpARMRSBSshiftLL: - return rewriteValueARM_OpARMRSBSshiftLL(v) + return rewriteValueARM_OpARMRSBSshiftLL_0(v) case OpARMRSBSshiftLLreg: - return rewriteValueARM_OpARMRSBSshiftLLreg(v) + return rewriteValueARM_OpARMRSBSshiftLLreg_0(v) case OpARMRSBSshiftRA: - return rewriteValueARM_OpARMRSBSshiftRA(v) + return rewriteValueARM_OpARMRSBSshiftRA_0(v) case OpARMRSBSshiftRAreg: - return rewriteValueARM_OpARMRSBSshiftRAreg(v) + return rewriteValueARM_OpARMRSBSshiftRAreg_0(v) case OpARMRSBSshiftRL: - return rewriteValueARM_OpARMRSBSshiftRL(v) + return rewriteValueARM_OpARMRSBSshiftRL_0(v) case OpARMRSBSshiftRLreg: - return rewriteValueARM_OpARMRSBSshiftRLreg(v) + return rewriteValueARM_OpARMRSBSshiftRLreg_0(v) case OpARMRSBconst: - return rewriteValueARM_OpARMRSBconst(v) + return rewriteValueARM_OpARMRSBconst_0(v) case OpARMRSBshiftLL: - return rewriteValueARM_OpARMRSBshiftLL(v) + return rewriteValueARM_OpARMRSBshiftLL_0(v) case OpARMRSBshiftLLreg: - return rewriteValueARM_OpARMRSBshiftLLreg(v) + return rewriteValueARM_OpARMRSBshiftLLreg_0(v) case OpARMRSBshiftRA: - return rewriteValueARM_OpARMRSBshiftRA(v) + return rewriteValueARM_OpARMRSBshiftRA_0(v) case OpARMRSBshiftRAreg: - return rewriteValueARM_OpARMRSBshiftRAreg(v) + return rewriteValueARM_OpARMRSBshiftRAreg_0(v) case OpARMRSBshiftRL: - return rewriteValueARM_OpARMRSBshiftRL(v) + return rewriteValueARM_OpARMRSBshiftRL_0(v) case OpARMRSBshiftRLreg: - return rewriteValueARM_OpARMRSBshiftRLreg(v) + return rewriteValueARM_OpARMRSBshiftRLreg_0(v) case OpARMRSCconst: - return rewriteValueARM_OpARMRSCconst(v) + return rewriteValueARM_OpARMRSCconst_0(v) case OpARMRSCshiftLL: - return rewriteValueARM_OpARMRSCshiftLL(v) + return rewriteValueARM_OpARMRSCshiftLL_0(v) case OpARMRSCshiftLLreg: - return rewriteValueARM_OpARMRSCshiftLLreg(v) + return rewriteValueARM_OpARMRSCshiftLLreg_0(v) case OpARMRSCshiftRA: - return rewriteValueARM_OpARMRSCshiftRA(v) + return rewriteValueARM_OpARMRSCshiftRA_0(v) case OpARMRSCshiftRAreg: - return rewriteValueARM_OpARMRSCshiftRAreg(v) + return rewriteValueARM_OpARMRSCshiftRAreg_0(v) case OpARMRSCshiftRL: - return rewriteValueARM_OpARMRSCshiftRL(v) + return rewriteValueARM_OpARMRSCshiftRL_0(v) case OpARMRSCshiftRLreg: - return rewriteValueARM_OpARMRSCshiftRLreg(v) + return rewriteValueARM_OpARMRSCshiftRLreg_0(v) case OpARMSBC: - return rewriteValueARM_OpARMSBC(v) + return rewriteValueARM_OpARMSBC_0(v) || rewriteValueARM_OpARMSBC_10(v) case OpARMSBCconst: - return rewriteValueARM_OpARMSBCconst(v) + return rewriteValueARM_OpARMSBCconst_0(v) case OpARMSBCshiftLL: - return rewriteValueARM_OpARMSBCshiftLL(v) + return rewriteValueARM_OpARMSBCshiftLL_0(v) case OpARMSBCshiftLLreg: - return rewriteValueARM_OpARMSBCshiftLLreg(v) + return rewriteValueARM_OpARMSBCshiftLLreg_0(v) case OpARMSBCshiftRA: - return rewriteValueARM_OpARMSBCshiftRA(v) + return rewriteValueARM_OpARMSBCshiftRA_0(v) case OpARMSBCshiftRAreg: - return rewriteValueARM_OpARMSBCshiftRAreg(v) + return rewriteValueARM_OpARMSBCshiftRAreg_0(v) case OpARMSBCshiftRL: - return rewriteValueARM_OpARMSBCshiftRL(v) + return rewriteValueARM_OpARMSBCshiftRL_0(v) case OpARMSBCshiftRLreg: - return rewriteValueARM_OpARMSBCshiftRLreg(v) + return rewriteValueARM_OpARMSBCshiftRLreg_0(v) case OpARMSLL: - return rewriteValueARM_OpARMSLL(v) + return rewriteValueARM_OpARMSLL_0(v) case OpARMSLLconst: - return rewriteValueARM_OpARMSLLconst(v) + return rewriteValueARM_OpARMSLLconst_0(v) case OpARMSRA: - return rewriteValueARM_OpARMSRA(v) + return rewriteValueARM_OpARMSRA_0(v) case OpARMSRAcond: - return rewriteValueARM_OpARMSRAcond(v) + return rewriteValueARM_OpARMSRAcond_0(v) case OpARMSRAconst: - return rewriteValueARM_OpARMSRAconst(v) + return rewriteValueARM_OpARMSRAconst_0(v) case OpARMSRL: - return rewriteValueARM_OpARMSRL(v) + return rewriteValueARM_OpARMSRL_0(v) case OpARMSRLconst: - return rewriteValueARM_OpARMSRLconst(v) + return rewriteValueARM_OpARMSRLconst_0(v) case OpARMSUB: - return rewriteValueARM_OpARMSUB(v) + return rewriteValueARM_OpARMSUB_0(v) || rewriteValueARM_OpARMSUB_10(v) case OpARMSUBS: - return rewriteValueARM_OpARMSUBS(v) + return rewriteValueARM_OpARMSUBS_0(v) || rewriteValueARM_OpARMSUBS_10(v) case OpARMSUBSshiftLL: - return rewriteValueARM_OpARMSUBSshiftLL(v) + return rewriteValueARM_OpARMSUBSshiftLL_0(v) case OpARMSUBSshiftLLreg: - return rewriteValueARM_OpARMSUBSshiftLLreg(v) + return rewriteValueARM_OpARMSUBSshiftLLreg_0(v) case OpARMSUBSshiftRA: - return rewriteValueARM_OpARMSUBSshiftRA(v) + return rewriteValueARM_OpARMSUBSshiftRA_0(v) case OpARMSUBSshiftRAreg: - return rewriteValueARM_OpARMSUBSshiftRAreg(v) + return rewriteValueARM_OpARMSUBSshiftRAreg_0(v) case OpARMSUBSshiftRL: - return rewriteValueARM_OpARMSUBSshiftRL(v) + return rewriteValueARM_OpARMSUBSshiftRL_0(v) case OpARMSUBSshiftRLreg: - return rewriteValueARM_OpARMSUBSshiftRLreg(v) + return rewriteValueARM_OpARMSUBSshiftRLreg_0(v) case OpARMSUBconst: - return rewriteValueARM_OpARMSUBconst(v) + return rewriteValueARM_OpARMSUBconst_0(v) case OpARMSUBshiftLL: - return rewriteValueARM_OpARMSUBshiftLL(v) + return rewriteValueARM_OpARMSUBshiftLL_0(v) case OpARMSUBshiftLLreg: - return rewriteValueARM_OpARMSUBshiftLLreg(v) + return rewriteValueARM_OpARMSUBshiftLLreg_0(v) case OpARMSUBshiftRA: - return rewriteValueARM_OpARMSUBshiftRA(v) + return rewriteValueARM_OpARMSUBshiftRA_0(v) case OpARMSUBshiftRAreg: - return rewriteValueARM_OpARMSUBshiftRAreg(v) + return rewriteValueARM_OpARMSUBshiftRAreg_0(v) case OpARMSUBshiftRL: - return rewriteValueARM_OpARMSUBshiftRL(v) + return rewriteValueARM_OpARMSUBshiftRL_0(v) case OpARMSUBshiftRLreg: - return rewriteValueARM_OpARMSUBshiftRLreg(v) + return rewriteValueARM_OpARMSUBshiftRLreg_0(v) case OpARMXOR: - return rewriteValueARM_OpARMXOR(v) + return rewriteValueARM_OpARMXOR_0(v) || rewriteValueARM_OpARMXOR_10(v) case OpARMXORconst: - return rewriteValueARM_OpARMXORconst(v) + return rewriteValueARM_OpARMXORconst_0(v) case OpARMXORshiftLL: - return rewriteValueARM_OpARMXORshiftLL(v) + return rewriteValueARM_OpARMXORshiftLL_0(v) case OpARMXORshiftLLreg: - return rewriteValueARM_OpARMXORshiftLLreg(v) + return rewriteValueARM_OpARMXORshiftLLreg_0(v) case OpARMXORshiftRA: - return rewriteValueARM_OpARMXORshiftRA(v) + return rewriteValueARM_OpARMXORshiftRA_0(v) case OpARMXORshiftRAreg: - return rewriteValueARM_OpARMXORshiftRAreg(v) + return rewriteValueARM_OpARMXORshiftRAreg_0(v) case OpARMXORshiftRL: - return rewriteValueARM_OpARMXORshiftRL(v) + return rewriteValueARM_OpARMXORshiftRL_0(v) case OpARMXORshiftRLreg: - return rewriteValueARM_OpARMXORshiftRLreg(v) + return rewriteValueARM_OpARMXORshiftRLreg_0(v) case OpARMXORshiftRR: - return rewriteValueARM_OpARMXORshiftRR(v) + return rewriteValueARM_OpARMXORshiftRR_0(v) case OpAdd16: - return rewriteValueARM_OpAdd16(v) + return rewriteValueARM_OpAdd16_0(v) case OpAdd32: - return rewriteValueARM_OpAdd32(v) + return rewriteValueARM_OpAdd32_0(v) case OpAdd32F: - return rewriteValueARM_OpAdd32F(v) + return rewriteValueARM_OpAdd32F_0(v) case OpAdd32carry: - return rewriteValueARM_OpAdd32carry(v) + return rewriteValueARM_OpAdd32carry_0(v) case OpAdd32withcarry: - return rewriteValueARM_OpAdd32withcarry(v) + return rewriteValueARM_OpAdd32withcarry_0(v) case OpAdd64F: - return rewriteValueARM_OpAdd64F(v) + return rewriteValueARM_OpAdd64F_0(v) case OpAdd8: - return rewriteValueARM_OpAdd8(v) + return rewriteValueARM_OpAdd8_0(v) case OpAddPtr: - return rewriteValueARM_OpAddPtr(v) + return rewriteValueARM_OpAddPtr_0(v) case OpAddr: - return rewriteValueARM_OpAddr(v) + return rewriteValueARM_OpAddr_0(v) case OpAnd16: - return rewriteValueARM_OpAnd16(v) + return rewriteValueARM_OpAnd16_0(v) case OpAnd32: - return rewriteValueARM_OpAnd32(v) + return rewriteValueARM_OpAnd32_0(v) case OpAnd8: - return rewriteValueARM_OpAnd8(v) + return rewriteValueARM_OpAnd8_0(v) case OpAndB: - return rewriteValueARM_OpAndB(v) + return rewriteValueARM_OpAndB_0(v) case OpAvg32u: - return rewriteValueARM_OpAvg32u(v) + return rewriteValueARM_OpAvg32u_0(v) case OpBitLen32: - return rewriteValueARM_OpBitLen32(v) + return rewriteValueARM_OpBitLen32_0(v) case OpBswap32: - return rewriteValueARM_OpBswap32(v) + return rewriteValueARM_OpBswap32_0(v) case OpClosureCall: - return rewriteValueARM_OpClosureCall(v) + return rewriteValueARM_OpClosureCall_0(v) case OpCom16: - return rewriteValueARM_OpCom16(v) + return rewriteValueARM_OpCom16_0(v) case OpCom32: - return rewriteValueARM_OpCom32(v) + return rewriteValueARM_OpCom32_0(v) case OpCom8: - return rewriteValueARM_OpCom8(v) + return rewriteValueARM_OpCom8_0(v) case OpConst16: - return rewriteValueARM_OpConst16(v) + return rewriteValueARM_OpConst16_0(v) case OpConst32: - return rewriteValueARM_OpConst32(v) + return rewriteValueARM_OpConst32_0(v) case OpConst32F: - return rewriteValueARM_OpConst32F(v) + return rewriteValueARM_OpConst32F_0(v) case OpConst64F: - return rewriteValueARM_OpConst64F(v) + return rewriteValueARM_OpConst64F_0(v) case OpConst8: - return rewriteValueARM_OpConst8(v) + return rewriteValueARM_OpConst8_0(v) case OpConstBool: - return rewriteValueARM_OpConstBool(v) + return rewriteValueARM_OpConstBool_0(v) case OpConstNil: - return rewriteValueARM_OpConstNil(v) + return rewriteValueARM_OpConstNil_0(v) case OpConvert: - return rewriteValueARM_OpConvert(v) + return rewriteValueARM_OpConvert_0(v) case OpCtz32: - return rewriteValueARM_OpCtz32(v) + return rewriteValueARM_OpCtz32_0(v) case OpCvt32Fto32: - return rewriteValueARM_OpCvt32Fto32(v) + return rewriteValueARM_OpCvt32Fto32_0(v) case OpCvt32Fto32U: - return rewriteValueARM_OpCvt32Fto32U(v) + return rewriteValueARM_OpCvt32Fto32U_0(v) case OpCvt32Fto64F: - return rewriteValueARM_OpCvt32Fto64F(v) + return rewriteValueARM_OpCvt32Fto64F_0(v) case OpCvt32Uto32F: - return rewriteValueARM_OpCvt32Uto32F(v) + return rewriteValueARM_OpCvt32Uto32F_0(v) case OpCvt32Uto64F: - return rewriteValueARM_OpCvt32Uto64F(v) + return rewriteValueARM_OpCvt32Uto64F_0(v) case OpCvt32to32F: - return rewriteValueARM_OpCvt32to32F(v) + return rewriteValueARM_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueARM_OpCvt32to64F(v) + return rewriteValueARM_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueARM_OpCvt64Fto32(v) + return rewriteValueARM_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueARM_OpCvt64Fto32F(v) + return rewriteValueARM_OpCvt64Fto32F_0(v) case OpCvt64Fto32U: - return rewriteValueARM_OpCvt64Fto32U(v) + return rewriteValueARM_OpCvt64Fto32U_0(v) case OpDiv16: - return rewriteValueARM_OpDiv16(v) + return rewriteValueARM_OpDiv16_0(v) case OpDiv16u: - return rewriteValueARM_OpDiv16u(v) + return rewriteValueARM_OpDiv16u_0(v) case OpDiv32: - return rewriteValueARM_OpDiv32(v) + return rewriteValueARM_OpDiv32_0(v) case OpDiv32F: - return rewriteValueARM_OpDiv32F(v) + return rewriteValueARM_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueARM_OpDiv32u(v) + return rewriteValueARM_OpDiv32u_0(v) case OpDiv64F: - return rewriteValueARM_OpDiv64F(v) + return rewriteValueARM_OpDiv64F_0(v) case OpDiv8: - return rewriteValueARM_OpDiv8(v) + return rewriteValueARM_OpDiv8_0(v) case OpDiv8u: - return rewriteValueARM_OpDiv8u(v) + return rewriteValueARM_OpDiv8u_0(v) case OpEq16: - return rewriteValueARM_OpEq16(v) + return rewriteValueARM_OpEq16_0(v) case OpEq32: - return rewriteValueARM_OpEq32(v) + return rewriteValueARM_OpEq32_0(v) case OpEq32F: - return rewriteValueARM_OpEq32F(v) + return rewriteValueARM_OpEq32F_0(v) case OpEq64F: - return rewriteValueARM_OpEq64F(v) + return rewriteValueARM_OpEq64F_0(v) case OpEq8: - return rewriteValueARM_OpEq8(v) + return rewriteValueARM_OpEq8_0(v) case OpEqB: - return rewriteValueARM_OpEqB(v) + return rewriteValueARM_OpEqB_0(v) case OpEqPtr: - return rewriteValueARM_OpEqPtr(v) + return rewriteValueARM_OpEqPtr_0(v) case OpGeq16: - return rewriteValueARM_OpGeq16(v) + return rewriteValueARM_OpGeq16_0(v) case OpGeq16U: - return rewriteValueARM_OpGeq16U(v) + return rewriteValueARM_OpGeq16U_0(v) case OpGeq32: - return rewriteValueARM_OpGeq32(v) + return rewriteValueARM_OpGeq32_0(v) case OpGeq32F: - return rewriteValueARM_OpGeq32F(v) + return rewriteValueARM_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueARM_OpGeq32U(v) + return rewriteValueARM_OpGeq32U_0(v) case OpGeq64F: - return rewriteValueARM_OpGeq64F(v) + return rewriteValueARM_OpGeq64F_0(v) case OpGeq8: - return rewriteValueARM_OpGeq8(v) + return rewriteValueARM_OpGeq8_0(v) case OpGeq8U: - return rewriteValueARM_OpGeq8U(v) + return rewriteValueARM_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueARM_OpGetClosurePtr(v) + return rewriteValueARM_OpGetClosurePtr_0(v) case OpGreater16: - return rewriteValueARM_OpGreater16(v) + return rewriteValueARM_OpGreater16_0(v) case OpGreater16U: - return rewriteValueARM_OpGreater16U(v) + return rewriteValueARM_OpGreater16U_0(v) case OpGreater32: - return rewriteValueARM_OpGreater32(v) + return rewriteValueARM_OpGreater32_0(v) case OpGreater32F: - return rewriteValueARM_OpGreater32F(v) + return rewriteValueARM_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueARM_OpGreater32U(v) + return rewriteValueARM_OpGreater32U_0(v) case OpGreater64F: - return rewriteValueARM_OpGreater64F(v) + return rewriteValueARM_OpGreater64F_0(v) case OpGreater8: - return rewriteValueARM_OpGreater8(v) + return rewriteValueARM_OpGreater8_0(v) case OpGreater8U: - return rewriteValueARM_OpGreater8U(v) + return rewriteValueARM_OpGreater8U_0(v) case OpHmul32: - return rewriteValueARM_OpHmul32(v) + return rewriteValueARM_OpHmul32_0(v) case OpHmul32u: - return rewriteValueARM_OpHmul32u(v) + return rewriteValueARM_OpHmul32u_0(v) case OpInterCall: - return rewriteValueARM_OpInterCall(v) + return rewriteValueARM_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueARM_OpIsInBounds(v) + return rewriteValueARM_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueARM_OpIsNonNil(v) + return rewriteValueARM_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueARM_OpIsSliceInBounds(v) + return rewriteValueARM_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueARM_OpLeq16(v) + return rewriteValueARM_OpLeq16_0(v) case OpLeq16U: - return rewriteValueARM_OpLeq16U(v) + return rewriteValueARM_OpLeq16U_0(v) case OpLeq32: - return rewriteValueARM_OpLeq32(v) + return rewriteValueARM_OpLeq32_0(v) case OpLeq32F: - return rewriteValueARM_OpLeq32F(v) + return rewriteValueARM_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueARM_OpLeq32U(v) + return rewriteValueARM_OpLeq32U_0(v) case OpLeq64F: - return rewriteValueARM_OpLeq64F(v) + return rewriteValueARM_OpLeq64F_0(v) case OpLeq8: - return rewriteValueARM_OpLeq8(v) + return rewriteValueARM_OpLeq8_0(v) case OpLeq8U: - return rewriteValueARM_OpLeq8U(v) + return rewriteValueARM_OpLeq8U_0(v) case OpLess16: - return rewriteValueARM_OpLess16(v) + return rewriteValueARM_OpLess16_0(v) case OpLess16U: - return rewriteValueARM_OpLess16U(v) + return rewriteValueARM_OpLess16U_0(v) case OpLess32: - return rewriteValueARM_OpLess32(v) + return rewriteValueARM_OpLess32_0(v) case OpLess32F: - return rewriteValueARM_OpLess32F(v) + return rewriteValueARM_OpLess32F_0(v) case OpLess32U: - return rewriteValueARM_OpLess32U(v) + return rewriteValueARM_OpLess32U_0(v) case OpLess64F: - return rewriteValueARM_OpLess64F(v) + return rewriteValueARM_OpLess64F_0(v) case OpLess8: - return rewriteValueARM_OpLess8(v) + return rewriteValueARM_OpLess8_0(v) case OpLess8U: - return rewriteValueARM_OpLess8U(v) + return rewriteValueARM_OpLess8U_0(v) case OpLoad: - return rewriteValueARM_OpLoad(v) + return rewriteValueARM_OpLoad_0(v) case OpLsh16x16: - return rewriteValueARM_OpLsh16x16(v) + return rewriteValueARM_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueARM_OpLsh16x32(v) + return rewriteValueARM_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueARM_OpLsh16x64(v) + return rewriteValueARM_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueARM_OpLsh16x8(v) + return rewriteValueARM_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueARM_OpLsh32x16(v) + return rewriteValueARM_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueARM_OpLsh32x32(v) + return rewriteValueARM_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueARM_OpLsh32x64(v) + return rewriteValueARM_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueARM_OpLsh32x8(v) + return rewriteValueARM_OpLsh32x8_0(v) case OpLsh8x16: - return rewriteValueARM_OpLsh8x16(v) + return rewriteValueARM_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueARM_OpLsh8x32(v) + return rewriteValueARM_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueARM_OpLsh8x64(v) + return rewriteValueARM_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueARM_OpLsh8x8(v) + return rewriteValueARM_OpLsh8x8_0(v) case OpMod16: - return rewriteValueARM_OpMod16(v) + return rewriteValueARM_OpMod16_0(v) case OpMod16u: - return rewriteValueARM_OpMod16u(v) + return rewriteValueARM_OpMod16u_0(v) case OpMod32: - return rewriteValueARM_OpMod32(v) + return rewriteValueARM_OpMod32_0(v) case OpMod32u: - return rewriteValueARM_OpMod32u(v) + return rewriteValueARM_OpMod32u_0(v) case OpMod8: - return rewriteValueARM_OpMod8(v) + return rewriteValueARM_OpMod8_0(v) case OpMod8u: - return rewriteValueARM_OpMod8u(v) + return rewriteValueARM_OpMod8u_0(v) case OpMove: - return rewriteValueARM_OpMove(v) + return rewriteValueARM_OpMove_0(v) case OpMul16: - return rewriteValueARM_OpMul16(v) + return rewriteValueARM_OpMul16_0(v) case OpMul32: - return rewriteValueARM_OpMul32(v) + return rewriteValueARM_OpMul32_0(v) case OpMul32F: - return rewriteValueARM_OpMul32F(v) + return rewriteValueARM_OpMul32F_0(v) case OpMul32uhilo: - return rewriteValueARM_OpMul32uhilo(v) + return rewriteValueARM_OpMul32uhilo_0(v) case OpMul64F: - return rewriteValueARM_OpMul64F(v) + return rewriteValueARM_OpMul64F_0(v) case OpMul8: - return rewriteValueARM_OpMul8(v) + return rewriteValueARM_OpMul8_0(v) case OpNeg16: - return rewriteValueARM_OpNeg16(v) + return rewriteValueARM_OpNeg16_0(v) case OpNeg32: - return rewriteValueARM_OpNeg32(v) + return rewriteValueARM_OpNeg32_0(v) case OpNeg32F: - return rewriteValueARM_OpNeg32F(v) + return rewriteValueARM_OpNeg32F_0(v) case OpNeg64F: - return rewriteValueARM_OpNeg64F(v) + return rewriteValueARM_OpNeg64F_0(v) case OpNeg8: - return rewriteValueARM_OpNeg8(v) + return rewriteValueARM_OpNeg8_0(v) case OpNeq16: - return rewriteValueARM_OpNeq16(v) + return rewriteValueARM_OpNeq16_0(v) case OpNeq32: - return rewriteValueARM_OpNeq32(v) + return rewriteValueARM_OpNeq32_0(v) case OpNeq32F: - return rewriteValueARM_OpNeq32F(v) + return rewriteValueARM_OpNeq32F_0(v) case OpNeq64F: - return rewriteValueARM_OpNeq64F(v) + return rewriteValueARM_OpNeq64F_0(v) case OpNeq8: - return rewriteValueARM_OpNeq8(v) + return rewriteValueARM_OpNeq8_0(v) case OpNeqB: - return rewriteValueARM_OpNeqB(v) + return rewriteValueARM_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueARM_OpNeqPtr(v) + return rewriteValueARM_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueARM_OpNilCheck(v) + return rewriteValueARM_OpNilCheck_0(v) case OpNot: - return rewriteValueARM_OpNot(v) + return rewriteValueARM_OpNot_0(v) case OpOffPtr: - return rewriteValueARM_OpOffPtr(v) + return rewriteValueARM_OpOffPtr_0(v) case OpOr16: - return rewriteValueARM_OpOr16(v) + return rewriteValueARM_OpOr16_0(v) case OpOr32: - return rewriteValueARM_OpOr32(v) + return rewriteValueARM_OpOr32_0(v) case OpOr8: - return rewriteValueARM_OpOr8(v) + return rewriteValueARM_OpOr8_0(v) case OpOrB: - return rewriteValueARM_OpOrB(v) + return rewriteValueARM_OpOrB_0(v) case OpRound32F: - return rewriteValueARM_OpRound32F(v) + return rewriteValueARM_OpRound32F_0(v) case OpRound64F: - return rewriteValueARM_OpRound64F(v) + return rewriteValueARM_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueARM_OpRsh16Ux16(v) + return rewriteValueARM_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueARM_OpRsh16Ux32(v) + return rewriteValueARM_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueARM_OpRsh16Ux64(v) + return rewriteValueARM_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueARM_OpRsh16Ux8(v) + return rewriteValueARM_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueARM_OpRsh16x16(v) + return rewriteValueARM_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueARM_OpRsh16x32(v) + return rewriteValueARM_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueARM_OpRsh16x64(v) + return rewriteValueARM_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueARM_OpRsh16x8(v) + return rewriteValueARM_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueARM_OpRsh32Ux16(v) + return rewriteValueARM_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueARM_OpRsh32Ux32(v) + return rewriteValueARM_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueARM_OpRsh32Ux64(v) + return rewriteValueARM_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueARM_OpRsh32Ux8(v) + return rewriteValueARM_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueARM_OpRsh32x16(v) + return rewriteValueARM_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueARM_OpRsh32x32(v) + return rewriteValueARM_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueARM_OpRsh32x64(v) + return rewriteValueARM_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueARM_OpRsh32x8(v) + return rewriteValueARM_OpRsh32x8_0(v) case OpRsh8Ux16: - return rewriteValueARM_OpRsh8Ux16(v) + return rewriteValueARM_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueARM_OpRsh8Ux32(v) + return rewriteValueARM_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueARM_OpRsh8Ux64(v) + return rewriteValueARM_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueARM_OpRsh8Ux8(v) + return rewriteValueARM_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueARM_OpRsh8x16(v) + return rewriteValueARM_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueARM_OpRsh8x32(v) + return rewriteValueARM_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueARM_OpRsh8x64(v) + return rewriteValueARM_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueARM_OpRsh8x8(v) + return rewriteValueARM_OpRsh8x8_0(v) case OpSelect0: - return rewriteValueARM_OpSelect0(v) + return rewriteValueARM_OpSelect0_0(v) case OpSelect1: - return rewriteValueARM_OpSelect1(v) + return rewriteValueARM_OpSelect1_0(v) case OpSignExt16to32: - return rewriteValueARM_OpSignExt16to32(v) + return rewriteValueARM_OpSignExt16to32_0(v) case OpSignExt8to16: - return rewriteValueARM_OpSignExt8to16(v) + return rewriteValueARM_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueARM_OpSignExt8to32(v) + return rewriteValueARM_OpSignExt8to32_0(v) case OpSignmask: - return rewriteValueARM_OpSignmask(v) + return rewriteValueARM_OpSignmask_0(v) case OpSlicemask: - return rewriteValueARM_OpSlicemask(v) + return rewriteValueARM_OpSlicemask_0(v) case OpSqrt: - return rewriteValueARM_OpSqrt(v) + return rewriteValueARM_OpSqrt_0(v) case OpStaticCall: - return rewriteValueARM_OpStaticCall(v) + return rewriteValueARM_OpStaticCall_0(v) case OpStore: - return rewriteValueARM_OpStore(v) + return rewriteValueARM_OpStore_0(v) case OpSub16: - return rewriteValueARM_OpSub16(v) + return rewriteValueARM_OpSub16_0(v) case OpSub32: - return rewriteValueARM_OpSub32(v) + return rewriteValueARM_OpSub32_0(v) case OpSub32F: - return rewriteValueARM_OpSub32F(v) + return rewriteValueARM_OpSub32F_0(v) case OpSub32carry: - return rewriteValueARM_OpSub32carry(v) + return rewriteValueARM_OpSub32carry_0(v) case OpSub32withcarry: - return rewriteValueARM_OpSub32withcarry(v) + return rewriteValueARM_OpSub32withcarry_0(v) case OpSub64F: - return rewriteValueARM_OpSub64F(v) + return rewriteValueARM_OpSub64F_0(v) case OpSub8: - return rewriteValueARM_OpSub8(v) + return rewriteValueARM_OpSub8_0(v) case OpSubPtr: - return rewriteValueARM_OpSubPtr(v) + return rewriteValueARM_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueARM_OpTrunc16to8(v) + return rewriteValueARM_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueARM_OpTrunc32to16(v) + return rewriteValueARM_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueARM_OpTrunc32to8(v) + return rewriteValueARM_OpTrunc32to8_0(v) case OpXor16: - return rewriteValueARM_OpXor16(v) + return rewriteValueARM_OpXor16_0(v) case OpXor32: - return rewriteValueARM_OpXor32(v) + return rewriteValueARM_OpXor32_0(v) case OpXor8: - return rewriteValueARM_OpXor8(v) + return rewriteValueARM_OpXor8_0(v) case OpZero: - return rewriteValueARM_OpZero(v) + return rewriteValueARM_OpZero_0(v) case OpZeroExt16to32: - return rewriteValueARM_OpZeroExt16to32(v) + return rewriteValueARM_OpZeroExt16to32_0(v) case OpZeroExt8to16: - return rewriteValueARM_OpZeroExt8to16(v) + return rewriteValueARM_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueARM_OpZeroExt8to32(v) + return rewriteValueARM_OpZeroExt8to32_0(v) case OpZeromask: - return rewriteValueARM_OpZeromask(v) + return rewriteValueARM_OpZeromask_0(v) } return false } -func rewriteValueARM_OpARMADC(v *Value) bool { +func rewriteValueARM_OpARMADC_0(v *Value) bool { // match: (ADC (MOVWconst [c]) x flags) // cond: // result: (ADCconst [c] x flags) @@ -911,6 +911,9 @@ func rewriteValueARM_OpARMADC(v *Value) bool { v.AddArg(flags) return true } + return false +} +func rewriteValueARM_OpARMADC_10(v *Value) bool { // match: (ADC (SRLconst [c] y) x flags) // cond: // result: (ADCshiftRL x y [c] flags) @@ -1101,6 +1104,9 @@ func rewriteValueARM_OpARMADC(v *Value) bool { v.AddArg(flags) return true } + return false +} +func rewriteValueARM_OpARMADC_20(v *Value) bool { // match: (ADC x (SRL y z) flags) // cond: // result: (ADCshiftRLreg x y z flags) @@ -1255,7 +1261,7 @@ func rewriteValueARM_OpARMADC(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCconst(v *Value) bool { +func rewriteValueARM_OpARMADCconst_0(v *Value) bool { // match: (ADCconst [c] (ADDconst [d] x) flags) // cond: // result: (ADCconst [int64(int32(c+d))] x flags) @@ -1294,7 +1300,7 @@ func rewriteValueARM_OpARMADCconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftLL(v *Value) bool { +func rewriteValueARM_OpARMADCshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftLL (MOVWconst [c]) x [d] flags) @@ -1338,7 +1344,7 @@ func rewriteValueARM_OpARMADCshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMADCshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftLLreg (MOVWconst [c]) x y flags) @@ -1383,7 +1389,7 @@ func rewriteValueARM_OpARMADCshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftRA(v *Value) bool { +func rewriteValueARM_OpARMADCshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRA (MOVWconst [c]) x [d] flags) @@ -1427,7 +1433,7 @@ func rewriteValueARM_OpARMADCshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMADCshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRAreg (MOVWconst [c]) x y flags) @@ -1472,7 +1478,7 @@ func rewriteValueARM_OpARMADCshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftRL(v *Value) bool { +func rewriteValueARM_OpARMADCshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRL (MOVWconst [c]) x [d] flags) @@ -1516,7 +1522,7 @@ func rewriteValueARM_OpARMADCshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMADCshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADCshiftRLreg (MOVWconst [c]) x y flags) @@ -1561,9 +1567,7 @@ func rewriteValueARM_OpARMADCshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADD(v *Value) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMADD_0(v *Value) bool { // match: (ADD x (MOVWconst [c])) // cond: // result: (ADDconst [c] x) @@ -1730,6 +1734,11 @@ func rewriteValueARM_OpARMADD(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMADD_10(v *Value) bool { + b := v.Block + _ = b // match: (ADD x (SRL y z)) // cond: // result: (ADDshiftRLreg x y z) @@ -1920,7 +1929,7 @@ func rewriteValueARM_OpARMADD(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDS(v *Value) bool { +func rewriteValueARM_OpARMADDS_0(v *Value) bool { // match: (ADDS x (MOVWconst [c])) // cond: // result: (ADDSconst [c] x) @@ -2087,6 +2096,9 @@ func rewriteValueARM_OpARMADDS(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMADDS_10(v *Value) bool { // match: (ADDS x (SRL y z)) // cond: // result: (ADDSshiftRLreg x y z) @@ -2157,7 +2169,7 @@ func rewriteValueARM_OpARMADDS(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftLL (MOVWconst [c]) x [d]) @@ -2197,7 +2209,7 @@ func rewriteValueARM_OpARMADDSshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftLLreg (MOVWconst [c]) x y) @@ -2238,7 +2250,7 @@ func rewriteValueARM_OpARMADDSshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRA (MOVWconst [c]) x [d]) @@ -2278,7 +2290,7 @@ func rewriteValueARM_OpARMADDSshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRAreg (MOVWconst [c]) x y) @@ -2319,7 +2331,7 @@ func rewriteValueARM_OpARMADDSshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRL (MOVWconst [c]) x [d]) @@ -2359,7 +2371,7 @@ func rewriteValueARM_OpARMADDSshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMADDSshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDSshiftRLreg (MOVWconst [c]) x y) @@ -2400,7 +2412,7 @@ func rewriteValueARM_OpARMADDSshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDconst(v *Value) bool { +func rewriteValueARM_OpARMADDconst_0(v *Value) bool { // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) // cond: // result: (MOVWaddr [off1+off2] {sym} ptr) @@ -2496,7 +2508,7 @@ func rewriteValueARM_OpARMADDconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftLL(v *Value) bool { +func rewriteValueARM_OpARMADDshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLL (MOVWconst [c]) x [d]) @@ -2557,7 +2569,7 @@ func rewriteValueARM_OpARMADDshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMADDshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLLreg (MOVWconst [c]) x y) @@ -2598,7 +2610,7 @@ func rewriteValueARM_OpARMADDshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftRA(v *Value) bool { +func rewriteValueARM_OpARMADDshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRA (MOVWconst [c]) x [d]) @@ -2638,7 +2650,7 @@ func rewriteValueARM_OpARMADDshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMADDshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRAreg (MOVWconst [c]) x y) @@ -2679,7 +2691,7 @@ func rewriteValueARM_OpARMADDshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftRL(v *Value) bool { +func rewriteValueARM_OpARMADDshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRL (MOVWconst [c]) x [d]) @@ -2740,7 +2752,7 @@ func rewriteValueARM_OpARMADDshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMADDshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRLreg (MOVWconst [c]) x y) @@ -2781,7 +2793,7 @@ func rewriteValueARM_OpARMADDshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMAND(v *Value) bool { +func rewriteValueARM_OpARMAND_0(v *Value) bool { // match: (AND x (MOVWconst [c])) // cond: // result: (ANDconst [c] x) @@ -2948,6 +2960,9 @@ func rewriteValueARM_OpARMAND(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMAND_10(v *Value) bool { // match: (AND x (SRL y z)) // cond: // result: (ANDshiftRLreg x y z) @@ -3110,6 +3125,9 @@ func rewriteValueARM_OpARMAND(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueARM_OpARMAND_20(v *Value) bool { // match: (AND (MVNshiftRL y [c]) x) // cond: // result: (BICshiftRL x y [c]) @@ -3163,7 +3181,7 @@ func rewriteValueARM_OpARMAND(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDconst(v *Value) bool { +func rewriteValueARM_OpARMANDconst_0(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVWconst [0]) @@ -3221,7 +3239,7 @@ func rewriteValueARM_OpARMANDconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftLL(v *Value) bool { +func rewriteValueARM_OpARMANDshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLL (MOVWconst [c]) x [d]) @@ -3283,7 +3301,7 @@ func rewriteValueARM_OpARMANDshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMANDshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLLreg (MOVWconst [c]) x y) @@ -3324,7 +3342,7 @@ func rewriteValueARM_OpARMANDshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftRA(v *Value) bool { +func rewriteValueARM_OpARMANDshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRA (MOVWconst [c]) x [d]) @@ -3386,7 +3404,7 @@ func rewriteValueARM_OpARMANDshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMANDshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRAreg (MOVWconst [c]) x y) @@ -3427,7 +3445,7 @@ func rewriteValueARM_OpARMANDshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftRL(v *Value) bool { +func rewriteValueARM_OpARMANDshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRL (MOVWconst [c]) x [d]) @@ -3489,7 +3507,7 @@ func rewriteValueARM_OpARMANDshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMANDshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRLreg (MOVWconst [c]) x y) @@ -3530,7 +3548,7 @@ func rewriteValueARM_OpARMANDshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMBIC(v *Value) bool { +func rewriteValueARM_OpARMBIC_0(v *Value) bool { // match: (BIC x (MOVWconst [c])) // cond: // result: (BICconst [c] x) @@ -3662,7 +3680,7 @@ func rewriteValueARM_OpARMBIC(v *Value) bool { } return false } -func rewriteValueARM_OpARMBICconst(v *Value) bool { +func rewriteValueARM_OpARMBICconst_0(v *Value) bool { // match: (BICconst [0] x) // cond: // result: x @@ -3704,7 +3722,7 @@ func rewriteValueARM_OpARMBICconst(v *Value) bool { } 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))]) @@ -3804,7 +3822,7 @@ func rewriteValueARM_OpARMBICshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMBICshiftRAreg_0(v *Value) bool { // match: (BICshiftRAreg x y (MOVWconst [c])) // cond: // result: (BICshiftRA x y [c]) @@ -3824,7 +3842,7 @@ func rewriteValueARM_OpARMBICshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMBICshiftRL(v *Value) bool { +func rewriteValueARM_OpARMBICshiftRL_0(v *Value) bool { // match: (BICshiftRL x (MOVWconst [c]) [d]) // cond: // result: (BICconst x [int64(uint32(c)>>uint64(d))]) @@ -3864,7 +3882,7 @@ func rewriteValueARM_OpARMBICshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMBICshiftRLreg_0(v *Value) bool { // match: (BICshiftRLreg x y (MOVWconst [c])) // cond: // result: (BICshiftRL x y [c]) @@ -3884,7 +3902,7 @@ func rewriteValueARM_OpARMBICshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool { +func rewriteValueARM_OpARMCMOVWHSconst_0(v *Value) bool { // match: (CMOVWHSconst _ (FlagEQ) [c]) // cond: // result: (MOVWconst [c]) @@ -3971,7 +3989,7 @@ func rewriteValueARM_OpARMCMOVWHSconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool { +func rewriteValueARM_OpARMCMOVWLSconst_0(v *Value) bool { // match: (CMOVWLSconst _ (FlagEQ) [c]) // cond: // result: (MOVWconst [c]) @@ -4058,7 +4076,7 @@ func rewriteValueARM_OpARMCMOVWLSconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMP(v *Value) bool { +func rewriteValueARM_OpARMCMP_0(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVWconst [c])) @@ -4237,6 +4255,11 @@ func rewriteValueARM_OpARMCMP(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValueARM_OpARMCMP_10(v *Value) bool { + b := v.Block + _ = b // match: (CMP x (SRL y z)) // cond: // result: (CMPshiftRLreg x y z) @@ -4311,7 +4334,7 @@ func rewriteValueARM_OpARMCMP(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPD(v *Value) bool { +func rewriteValueARM_OpARMCMPD_0(v *Value) bool { // match: (CMPD x (MOVDconst [0])) // cond: // result: (CMPD0 x) @@ -4330,7 +4353,7 @@ func rewriteValueARM_OpARMCMPD(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPF(v *Value) bool { +func rewriteValueARM_OpARMCMPF_0(v *Value) bool { // match: (CMPF x (MOVFconst [0])) // cond: // result: (CMPF0 x) @@ -4349,7 +4372,7 @@ func rewriteValueARM_OpARMCMPF(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPconst(v *Value) bool { +func rewriteValueARM_OpARMCMPconst_0(v *Value) bool { // match: (CMPconst (MOVWconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -4494,7 +4517,7 @@ func rewriteValueARM_OpARMCMPconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLL (MOVWconst [c]) x [d]) @@ -4536,7 +4559,7 @@ func rewriteValueARM_OpARMCMPshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLLreg (MOVWconst [c]) x y) @@ -4579,7 +4602,7 @@ func rewriteValueARM_OpARMCMPshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRA (MOVWconst [c]) x [d]) @@ -4621,7 +4644,7 @@ func rewriteValueARM_OpARMCMPshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRAreg (MOVWconst [c]) x y) @@ -4664,7 +4687,7 @@ func rewriteValueARM_OpARMCMPshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRL (MOVWconst [c]) x [d]) @@ -4706,7 +4729,7 @@ func rewriteValueARM_OpARMCMPshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMCMPshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRLreg (MOVWconst [c]) x y) @@ -4749,7 +4772,7 @@ func rewriteValueARM_OpARMCMPshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMEqual(v *Value) bool { +func rewriteValueARM_OpARMEqual_0(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4825,7 +4848,7 @@ func rewriteValueARM_OpARMEqual(v *Value) bool { } return false } -func rewriteValueARM_OpARMGreaterEqual(v *Value) bool { +func rewriteValueARM_OpARMGreaterEqual_0(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4901,7 +4924,7 @@ func rewriteValueARM_OpARMGreaterEqual(v *Value) bool { } return false } -func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool { +func rewriteValueARM_OpARMGreaterEqualU_0(v *Value) bool { // match: (GreaterEqualU (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -4977,7 +5000,7 @@ func rewriteValueARM_OpARMGreaterEqualU(v *Value) bool { } return false } -func rewriteValueARM_OpARMGreaterThan(v *Value) bool { +func rewriteValueARM_OpARMGreaterThan_0(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5053,7 +5076,7 @@ func rewriteValueARM_OpARMGreaterThan(v *Value) bool { } return false } -func rewriteValueARM_OpARMGreaterThanU(v *Value) bool { +func rewriteValueARM_OpARMGreaterThanU_0(v *Value) bool { // match: (GreaterThanU (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5129,7 +5152,7 @@ func rewriteValueARM_OpARMGreaterThanU(v *Value) bool { } return false } -func rewriteValueARM_OpARMLessEqual(v *Value) bool { +func rewriteValueARM_OpARMLessEqual_0(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -5205,7 +5228,7 @@ func rewriteValueARM_OpARMLessEqual(v *Value) bool { } return false } -func rewriteValueARM_OpARMLessEqualU(v *Value) bool { +func rewriteValueARM_OpARMLessEqualU_0(v *Value) bool { // match: (LessEqualU (FlagEQ)) // cond: // result: (MOVWconst [1]) @@ -5281,7 +5304,7 @@ func rewriteValueARM_OpARMLessEqualU(v *Value) bool { } return false } -func rewriteValueARM_OpARMLessThan(v *Value) bool { +func rewriteValueARM_OpARMLessThan_0(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5357,7 +5380,7 @@ func rewriteValueARM_OpARMLessThan(v *Value) bool { } return false } -func rewriteValueARM_OpARMLessThanU(v *Value) bool { +func rewriteValueARM_OpARMLessThanU_0(v *Value) bool { // match: (LessThanU (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -5433,7 +5456,7 @@ func rewriteValueARM_OpARMLessThanU(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVBUload(v *Value) bool { +func rewriteValueARM_OpARMMOVBUload_0(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -5503,7 +5526,7 @@ func rewriteValueARM_OpARMMOVBUload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVBUreg(v *Value) bool { +func rewriteValueARM_OpARMMOVBUreg_0(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVWreg x) @@ -5558,7 +5581,7 @@ func rewriteValueARM_OpARMMOVBUreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVBload(v *Value) bool { +func rewriteValueARM_OpARMMOVBload_0(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -5628,7 +5651,7 @@ func rewriteValueARM_OpARMMOVBload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVBreg(v *Value) bool { +func rewriteValueARM_OpARMMOVBreg_0(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVWreg x) @@ -5686,7 +5709,7 @@ func rewriteValueARM_OpARMMOVBreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVBstore(v *Value) bool { +func rewriteValueARM_OpARMMOVBstore_0(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -5821,7 +5844,7 @@ func rewriteValueARM_OpARMMOVBstore(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVDload(v *Value) bool { +func rewriteValueARM_OpARMMOVDload_0(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -5891,7 +5914,7 @@ func rewriteValueARM_OpARMMOVDload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVDstore(v *Value) bool { +func rewriteValueARM_OpARMMOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -5942,7 +5965,7 @@ func rewriteValueARM_OpARMMOVDstore(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVFload(v *Value) bool { +func rewriteValueARM_OpARMMOVFload_0(v *Value) bool { // match: (MOVFload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -6012,7 +6035,7 @@ func rewriteValueARM_OpARMMOVFload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVFstore(v *Value) bool { +func rewriteValueARM_OpARMMOVFstore_0(v *Value) bool { // match: (MOVFstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -6063,7 +6086,7 @@ func rewriteValueARM_OpARMMOVFstore(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVHUload(v *Value) bool { +func rewriteValueARM_OpARMMOVHUload_0(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -6133,7 +6156,7 @@ func rewriteValueARM_OpARMMOVHUload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVHUreg(v *Value) bool { +func rewriteValueARM_OpARMMOVHUreg_0(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVWreg x) @@ -6212,7 +6235,7 @@ func rewriteValueARM_OpARMMOVHUreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVHload(v *Value) bool { +func rewriteValueARM_OpARMMOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -6282,7 +6305,7 @@ func rewriteValueARM_OpARMMOVHload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVHreg(v *Value) bool { +func rewriteValueARM_OpARMMOVHreg_0(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVWreg x) @@ -6388,7 +6411,7 @@ func rewriteValueARM_OpARMMOVHreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVHstore(v *Value) bool { +func rewriteValueARM_OpARMMOVHstore_0(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -6481,7 +6504,7 @@ func rewriteValueARM_OpARMMOVHstore(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWload(v *Value) bool { +func rewriteValueARM_OpARMMOVWload_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6657,7 +6680,7 @@ func rewriteValueARM_OpARMMOVWload(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool { +func rewriteValueARM_OpARMMOVWloadidx_0(v *Value) bool { // match: (MOVWloadidx ptr idx (MOVWstoreidx ptr2 idx x _)) // cond: isSamePtr(ptr, ptr2) // result: x @@ -6831,7 +6854,7 @@ func rewriteValueARM_OpARMMOVWloadidx(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool { +func rewriteValueARM_OpARMMOVWloadshiftLL_0(v *Value) bool { // match: (MOVWloadshiftLL ptr idx [c] (MOVWstoreshiftLL ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6877,7 +6900,7 @@ func rewriteValueARM_OpARMMOVWloadshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool { +func rewriteValueARM_OpARMMOVWloadshiftRA_0(v *Value) bool { // match: (MOVWloadshiftRA ptr idx [c] (MOVWstoreshiftRA ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6923,7 +6946,7 @@ func rewriteValueARM_OpARMMOVWloadshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool { +func rewriteValueARM_OpARMMOVWloadshiftRL_0(v *Value) bool { // match: (MOVWloadshiftRL ptr idx [c] (MOVWstoreshiftRL ptr2 idx [d] x _)) // cond: c==d && isSamePtr(ptr, ptr2) // result: x @@ -6969,7 +6992,7 @@ func rewriteValueARM_OpARMMOVWloadshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWreg(v *Value) bool { +func rewriteValueARM_OpARMMOVWreg_0(v *Value) bool { // match: (MOVWreg x) // cond: x.Uses == 1 // result: (MOVWnop x) @@ -6997,7 +7020,7 @@ func rewriteValueARM_OpARMMOVWreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWstore(v *Value) bool { +func rewriteValueARM_OpARMMOVWstore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -7162,7 +7185,7 @@ func rewriteValueARM_OpARMMOVWstore(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool { +func rewriteValueARM_OpARMMOVWstoreidx_0(v *Value) bool { // match: (MOVWstoreidx ptr (MOVWconst [c]) val mem) // cond: // result: (MOVWstore [c] ptr val mem) @@ -7329,7 +7352,7 @@ func rewriteValueARM_OpARMMOVWstoreidx(v *Value) bool { } 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) @@ -7375,7 +7398,7 @@ func rewriteValueARM_OpARMMOVWstoreshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool { +func rewriteValueARM_OpARMMOVWstoreshiftRL_0(v *Value) bool { // match: (MOVWstoreshiftRL ptr (MOVWconst [c]) [d] val mem) // cond: // result: (MOVWstore [int64(uint32(c)>>uint64(d))] ptr val mem) @@ -7398,9 +7421,7 @@ func rewriteValueARM_OpARMMOVWstoreshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMMUL(v *Value) bool { - b := v.Block - _ = b +func rewriteValueARM_OpARMMUL_0(v *Value) bool { // match: (MUL x (MOVWconst [c])) // cond: int32(c) == -1 // result: (RSBconst [0] x) @@ -7575,6 +7596,11 @@ func rewriteValueARM_OpARMMUL(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueARM_OpARMMUL_10(v *Value) bool { + b := v.Block + _ = b // match: (MUL x (MOVWconst [c])) // cond: isPowerOfTwo(c+1) && int32(c) >= 7 // result: (RSBshiftLL x x [log2(c+1)]) @@ -7789,6 +7815,9 @@ func rewriteValueARM_OpARMMUL(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValueARM_OpARMMUL_20(v *Value) bool { // match: (MUL (MOVWconst [c]) (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(c*d))]) @@ -7827,7 +7856,7 @@ func rewriteValueARM_OpARMMUL(v *Value) bool { } return false } -func rewriteValueARM_OpARMMULA(v *Value) bool { +func rewriteValueARM_OpARMMULA_0(v *Value) bool { b := v.Block _ = b // match: (MULA x (MOVWconst [c]) a) @@ -8056,6 +8085,11 @@ func rewriteValueARM_OpARMMULA(v *Value) bool { v.AddArg(a) return true } + return false +} +func rewriteValueARM_OpARMMULA_10(v *Value) bool { + b := v.Block + _ = b // match: (MULA (MOVWconst [c]) x a) // cond: int32(c) == -1 // result: (SUB a x) @@ -8282,6 +8316,9 @@ func rewriteValueARM_OpARMMULA(v *Value) bool { v.AddArg(a) return true } + return false +} +func rewriteValueARM_OpARMMULA_20(v *Value) bool { // match: (MULA (MOVWconst [c]) (MOVWconst [d]) a) // cond: // result: (ADDconst [int64(int32(c*d))] a) @@ -8304,7 +8341,7 @@ func rewriteValueARM_OpARMMULA(v *Value) bool { } return false } -func rewriteValueARM_OpARMMVN(v *Value) bool { +func rewriteValueARM_OpARMMVN_0(v *Value) bool { // match: (MVN (MOVWconst [c])) // cond: // result: (MOVWconst [^c]) @@ -8410,7 +8447,7 @@ func rewriteValueARM_OpARMMVN(v *Value) bool { } 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))]) @@ -8462,7 +8499,7 @@ func rewriteValueARM_OpARMMVNshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMMVNshiftRAreg_0(v *Value) bool { // match: (MVNshiftRAreg x (MOVWconst [c])) // cond: // result: (MVNshiftRA x [c]) @@ -8480,7 +8517,7 @@ func rewriteValueARM_OpARMMVNshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool { +func rewriteValueARM_OpARMMVNshiftRL_0(v *Value) bool { // match: (MVNshiftRL (MOVWconst [c]) [d]) // cond: // result: (MOVWconst [^int64(uint32(c)>>uint64(d))]) @@ -8497,7 +8534,7 @@ func rewriteValueARM_OpARMMVNshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMMVNshiftRLreg_0(v *Value) bool { // match: (MVNshiftRLreg x (MOVWconst [c])) // cond: // result: (MVNshiftRL x [c]) @@ -8515,7 +8552,7 @@ func rewriteValueARM_OpARMMVNshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMNotEqual(v *Value) bool { +func rewriteValueARM_OpARMNotEqual_0(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVWconst [0]) @@ -8591,7 +8628,7 @@ func rewriteValueARM_OpARMNotEqual(v *Value) bool { } return false } -func rewriteValueARM_OpARMOR(v *Value) bool { +func rewriteValueARM_OpARMOR_0(v *Value) bool { // match: (OR x (MOVWconst [c])) // cond: // result: (ORconst [c] x) @@ -8758,6 +8795,9 @@ func rewriteValueARM_OpARMOR(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMOR_10(v *Value) bool { // match: (OR x (SRL y z)) // cond: // result: (ORshiftRLreg x y z) @@ -8841,7 +8881,7 @@ func rewriteValueARM_OpARMOR(v *Value) bool { } return false } -func rewriteValueARM_OpARMORconst(v *Value) bool { +func rewriteValueARM_OpARMORconst_0(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -8899,7 +8939,7 @@ func rewriteValueARM_OpARMORconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftLL(v *Value) bool { +func rewriteValueARM_OpARMORshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftLL (MOVWconst [c]) x [d]) @@ -8982,7 +9022,7 @@ func rewriteValueARM_OpARMORshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMORshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftLLreg (MOVWconst [c]) x y) @@ -9023,7 +9063,7 @@ func rewriteValueARM_OpARMORshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftRA(v *Value) bool { +func rewriteValueARM_OpARMORshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRA (MOVWconst [c]) x [d]) @@ -9085,7 +9125,7 @@ func rewriteValueARM_OpARMORshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMORshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRAreg (MOVWconst [c]) x y) @@ -9126,7 +9166,7 @@ func rewriteValueARM_OpARMORshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftRL(v *Value) bool { +func rewriteValueARM_OpARMORshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRL (MOVWconst [c]) x [d]) @@ -9209,7 +9249,7 @@ func rewriteValueARM_OpARMORshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMORshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRLreg (MOVWconst [c]) x y) @@ -9250,7 +9290,7 @@ func rewriteValueARM_OpARMORshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSB(v *Value) bool { +func rewriteValueARM_OpARMRSB_0(v *Value) bool { // match: (RSB (MOVWconst [c]) x) // cond: // result: (SUBconst [c] x) @@ -9417,6 +9457,9 @@ func rewriteValueARM_OpARMRSB(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMRSB_10(v *Value) bool { // match: (RSB x (SRL y z)) // cond: // result: (RSBshiftRLreg x y z) @@ -9499,7 +9542,7 @@ func rewriteValueARM_OpARMRSB(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftLL (MOVWconst [c]) x [d]) @@ -9539,7 +9582,7 @@ func rewriteValueARM_OpARMRSBSshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftLLreg (MOVWconst [c]) x y) @@ -9580,7 +9623,7 @@ func rewriteValueARM_OpARMRSBSshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRA (MOVWconst [c]) x [d]) @@ -9620,7 +9663,7 @@ func rewriteValueARM_OpARMRSBSshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRAreg (MOVWconst [c]) x y) @@ -9661,7 +9704,7 @@ func rewriteValueARM_OpARMRSBSshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRL (MOVWconst [c]) x [d]) @@ -9701,7 +9744,7 @@ func rewriteValueARM_OpARMRSBSshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMRSBSshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBSshiftRLreg (MOVWconst [c]) x y) @@ -9742,7 +9785,7 @@ func rewriteValueARM_OpARMRSBSshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBconst(v *Value) bool { +func rewriteValueARM_OpARMRSBconst_0(v *Value) bool { // match: (RSBconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(c-d))]) @@ -9807,7 +9850,7 @@ func rewriteValueARM_OpARMRSBconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftLL (MOVWconst [c]) x [d]) @@ -9868,7 +9911,7 @@ func rewriteValueARM_OpARMRSBshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftLLreg (MOVWconst [c]) x y) @@ -9909,7 +9952,7 @@ func rewriteValueARM_OpARMRSBshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRA (MOVWconst [c]) x [d]) @@ -9970,7 +10013,7 @@ func rewriteValueARM_OpARMRSBshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRAreg (MOVWconst [c]) x y) @@ -10011,7 +10054,7 @@ func rewriteValueARM_OpARMRSBshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRL (MOVWconst [c]) x [d]) @@ -10072,7 +10115,7 @@ func rewriteValueARM_OpARMRSBshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMRSBshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSBshiftRLreg (MOVWconst [c]) x y) @@ -10113,7 +10156,7 @@ func rewriteValueARM_OpARMRSBshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCconst(v *Value) bool { +func rewriteValueARM_OpARMRSCconst_0(v *Value) bool { // match: (RSCconst [c] (ADDconst [d] x) flags) // cond: // result: (RSCconst [int64(int32(c-d))] x flags) @@ -10152,7 +10195,7 @@ func rewriteValueARM_OpARMRSCconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftLL (MOVWconst [c]) x [d] flags) @@ -10196,7 +10239,7 @@ func rewriteValueARM_OpARMRSCshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftLLreg (MOVWconst [c]) x y flags) @@ -10241,7 +10284,7 @@ func rewriteValueARM_OpARMRSCshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRA (MOVWconst [c]) x [d] flags) @@ -10285,7 +10328,7 @@ func rewriteValueARM_OpARMRSCshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRAreg (MOVWconst [c]) x y flags) @@ -10330,7 +10373,7 @@ func rewriteValueARM_OpARMRSCshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRL (MOVWconst [c]) x [d] flags) @@ -10374,7 +10417,7 @@ func rewriteValueARM_OpARMRSCshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMRSCshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (RSCshiftRLreg (MOVWconst [c]) x y flags) @@ -10419,7 +10462,7 @@ func rewriteValueARM_OpARMRSCshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBC(v *Value) bool { +func rewriteValueARM_OpARMSBC_0(v *Value) bool { // match: (SBC (MOVWconst [c]) x flags) // cond: // result: (RSCconst [c] x flags) @@ -10606,6 +10649,9 @@ func rewriteValueARM_OpARMSBC(v *Value) bool { v.AddArg(flags) return true } + return false +} +func rewriteValueARM_OpARMSBC_10(v *Value) bool { // match: (SBC x (SRL y z) flags) // cond: // result: (SBCshiftRLreg x y z flags) @@ -10684,7 +10730,7 @@ func rewriteValueARM_OpARMSBC(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCconst(v *Value) bool { +func rewriteValueARM_OpARMSBCconst_0(v *Value) bool { // match: (SBCconst [c] (ADDconst [d] x) flags) // cond: // result: (SBCconst [int64(int32(c-d))] x flags) @@ -10723,7 +10769,7 @@ func rewriteValueARM_OpARMSBCconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftLL (MOVWconst [c]) x [d] flags) @@ -10767,7 +10813,7 @@ func rewriteValueARM_OpARMSBCshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftLLreg (MOVWconst [c]) x y flags) @@ -10812,7 +10858,7 @@ func rewriteValueARM_OpARMSBCshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRA (MOVWconst [c]) x [d] flags) @@ -10856,7 +10902,7 @@ func rewriteValueARM_OpARMSBCshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRAreg (MOVWconst [c]) x y flags) @@ -10901,7 +10947,7 @@ func rewriteValueARM_OpARMSBCshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRL (MOVWconst [c]) x [d] flags) @@ -10945,7 +10991,7 @@ func rewriteValueARM_OpARMSBCshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMSBCshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (SBCshiftRLreg (MOVWconst [c]) x y flags) @@ -10990,7 +11036,7 @@ func rewriteValueARM_OpARMSBCshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSLL(v *Value) bool { +func rewriteValueARM_OpARMSLL_0(v *Value) bool { // match: (SLL x (MOVWconst [c])) // cond: // result: (SLLconst x [c&31]) @@ -11008,7 +11054,7 @@ func rewriteValueARM_OpARMSLL(v *Value) bool { } 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))]) @@ -11135,7 +11181,7 @@ func rewriteValueARM_OpARMSRAconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMSRL(v *Value) bool { +func rewriteValueARM_OpARMSRL_0(v *Value) bool { // match: (SRL x (MOVWconst [c])) // cond: // result: (SRLconst x [c&31]) @@ -11153,7 +11199,7 @@ func rewriteValueARM_OpARMSRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSRLconst(v *Value) bool { +func rewriteValueARM_OpARMSRLconst_0(v *Value) bool { // match: (SRLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(uint32(d)>>uint64(c))]) @@ -11170,7 +11216,7 @@ func rewriteValueARM_OpARMSRLconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUB(v *Value) bool { +func rewriteValueARM_OpARMSUB_0(v *Value) bool { // match: (SUB (MOVWconst [c]) x) // cond: // result: (RSBconst [c] x) @@ -11337,6 +11383,9 @@ func rewriteValueARM_OpARMSUB(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMSUB_10(v *Value) bool { // match: (SUB x (SRL y z)) // cond: // result: (SUBshiftRLreg x y z) @@ -11419,7 +11468,7 @@ func rewriteValueARM_OpARMSUB(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBS(v *Value) bool { +func rewriteValueARM_OpARMSUBS_0(v *Value) bool { // match: (SUBS x (MOVWconst [c])) // cond: // result: (SUBSconst [c] x) @@ -11588,6 +11637,9 @@ func rewriteValueARM_OpARMSUBS(v *Value) bool { v.AddArg(z) return true } + return false +} +func rewriteValueARM_OpARMSUBS_10(v *Value) bool { // match: (SUBS (SRL y z) x) // cond: // result: (RSBSshiftRLreg x y z) @@ -11641,7 +11693,7 @@ func rewriteValueARM_OpARMSUBS(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftLL (MOVWconst [c]) x [d]) @@ -11681,7 +11733,7 @@ func rewriteValueARM_OpARMSUBSshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftLLreg (MOVWconst [c]) x y) @@ -11722,7 +11774,7 @@ func rewriteValueARM_OpARMSUBSshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRA (MOVWconst [c]) x [d]) @@ -11762,7 +11814,7 @@ func rewriteValueARM_OpARMSUBSshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRAreg (MOVWconst [c]) x y) @@ -11803,7 +11855,7 @@ func rewriteValueARM_OpARMSUBSshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRL (MOVWconst [c]) x [d]) @@ -11843,7 +11895,7 @@ func rewriteValueARM_OpARMSUBSshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMSUBSshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBSshiftRLreg (MOVWconst [c]) x y) @@ -11884,7 +11936,7 @@ func rewriteValueARM_OpARMSUBSshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBconst(v *Value) bool { +func rewriteValueARM_OpARMSUBconst_0(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -11962,7 +12014,7 @@ func rewriteValueARM_OpARMSUBconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftLL (MOVWconst [c]) x [d]) @@ -12023,7 +12075,7 @@ func rewriteValueARM_OpARMSUBshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftLLreg (MOVWconst [c]) x y) @@ -12064,7 +12116,7 @@ func rewriteValueARM_OpARMSUBshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRA (MOVWconst [c]) x [d]) @@ -12125,7 +12177,7 @@ func rewriteValueARM_OpARMSUBshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRAreg (MOVWconst [c]) x y) @@ -12166,7 +12218,7 @@ func rewriteValueARM_OpARMSUBshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRL (MOVWconst [c]) x [d]) @@ -12227,7 +12279,7 @@ func rewriteValueARM_OpARMSUBshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMSUBshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (SUBshiftRLreg (MOVWconst [c]) x y) @@ -12268,7 +12320,7 @@ func rewriteValueARM_OpARMSUBshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMXOR(v *Value) bool { +func rewriteValueARM_OpARMXOR_0(v *Value) bool { // match: (XOR x (MOVWconst [c])) // cond: // result: (XORconst [c] x) @@ -12435,6 +12487,9 @@ func rewriteValueARM_OpARMXOR(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueARM_OpARMXOR_10(v *Value) bool { // match: (XOR x (SLL y z)) // cond: // result: (XORshiftLLreg x y z) @@ -12551,7 +12606,7 @@ func rewriteValueARM_OpARMXOR(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORconst(v *Value) bool { +func rewriteValueARM_OpARMXORconst_0(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -12597,7 +12652,7 @@ func rewriteValueARM_OpARMXORconst(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftLL(v *Value) bool { +func rewriteValueARM_OpARMXORshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftLL (MOVWconst [c]) x [d]) @@ -12679,7 +12734,7 @@ func rewriteValueARM_OpARMXORshiftLL(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool { +func rewriteValueARM_OpARMXORshiftLLreg_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftLLreg (MOVWconst [c]) x y) @@ -12720,7 +12775,7 @@ func rewriteValueARM_OpARMXORshiftLLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftRA(v *Value) bool { +func rewriteValueARM_OpARMXORshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRA (MOVWconst [c]) x [d]) @@ -12781,7 +12836,7 @@ func rewriteValueARM_OpARMXORshiftRA(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool { +func rewriteValueARM_OpARMXORshiftRAreg_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRAreg (MOVWconst [c]) x y) @@ -12822,7 +12877,7 @@ func rewriteValueARM_OpARMXORshiftRAreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftRL(v *Value) bool { +func rewriteValueARM_OpARMXORshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRL (MOVWconst [c]) x [d]) @@ -12904,7 +12959,7 @@ func rewriteValueARM_OpARMXORshiftRL(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool { +func rewriteValueARM_OpARMXORshiftRLreg_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRLreg (MOVWconst [c]) x y) @@ -12945,7 +13000,7 @@ func rewriteValueARM_OpARMXORshiftRLreg(v *Value) bool { } return false } -func rewriteValueARM_OpARMXORshiftRR(v *Value) bool { +func rewriteValueARM_OpARMXORshiftRR_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRR (MOVWconst [c]) x [d]) @@ -12985,7 +13040,7 @@ func rewriteValueARM_OpARMXORshiftRR(v *Value) bool { } return false } -func rewriteValueARM_OpAdd16(v *Value) bool { +func rewriteValueARM_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -12998,7 +13053,7 @@ func rewriteValueARM_OpAdd16(v *Value) bool { return true } } -func rewriteValueARM_OpAdd32(v *Value) bool { +func rewriteValueARM_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -13011,7 +13066,7 @@ func rewriteValueARM_OpAdd32(v *Value) bool { return true } } -func rewriteValueARM_OpAdd32F(v *Value) bool { +func rewriteValueARM_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -13024,7 +13079,7 @@ func rewriteValueARM_OpAdd32F(v *Value) bool { return true } } -func rewriteValueARM_OpAdd32carry(v *Value) bool { +func rewriteValueARM_OpAdd32carry_0(v *Value) bool { // match: (Add32carry x y) // cond: // result: (ADDS x y) @@ -13037,7 +13092,7 @@ func rewriteValueARM_OpAdd32carry(v *Value) bool { return true } } -func rewriteValueARM_OpAdd32withcarry(v *Value) bool { +func rewriteValueARM_OpAdd32withcarry_0(v *Value) bool { // match: (Add32withcarry x y c) // cond: // result: (ADC x y c) @@ -13052,7 +13107,7 @@ func rewriteValueARM_OpAdd32withcarry(v *Value) bool { return true } } -func rewriteValueARM_OpAdd64F(v *Value) bool { +func rewriteValueARM_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -13065,7 +13120,7 @@ func rewriteValueARM_OpAdd64F(v *Value) bool { return true } } -func rewriteValueARM_OpAdd8(v *Value) bool { +func rewriteValueARM_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -13078,7 +13133,7 @@ func rewriteValueARM_OpAdd8(v *Value) bool { return true } } -func rewriteValueARM_OpAddPtr(v *Value) bool { +func rewriteValueARM_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -13091,7 +13146,7 @@ func rewriteValueARM_OpAddPtr(v *Value) bool { return true } } -func rewriteValueARM_OpAddr(v *Value) bool { +func rewriteValueARM_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVWaddr {sym} base) @@ -13104,7 +13159,7 @@ func rewriteValueARM_OpAddr(v *Value) bool { return true } } -func rewriteValueARM_OpAnd16(v *Value) bool { +func rewriteValueARM_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -13117,7 +13172,7 @@ func rewriteValueARM_OpAnd16(v *Value) bool { return true } } -func rewriteValueARM_OpAnd32(v *Value) bool { +func rewriteValueARM_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -13130,7 +13185,7 @@ func rewriteValueARM_OpAnd32(v *Value) bool { return true } } -func rewriteValueARM_OpAnd8(v *Value) bool { +func rewriteValueARM_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -13143,7 +13198,7 @@ func rewriteValueARM_OpAnd8(v *Value) bool { return true } } -func rewriteValueARM_OpAndB(v *Value) bool { +func rewriteValueARM_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -13156,7 +13211,7 @@ func rewriteValueARM_OpAndB(v *Value) bool { return true } } -func rewriteValueARM_OpAvg32u(v *Value) bool { +func rewriteValueARM_OpAvg32u_0(v *Value) bool { b := v.Block _ = b // match: (Avg32u x y) @@ -13178,7 +13233,7 @@ func rewriteValueARM_OpAvg32u(v *Value) bool { return true } } -func rewriteValueARM_OpBitLen32(v *Value) bool { +func rewriteValueARM_OpBitLen32_0(v *Value) bool { b := v.Block _ = b // match: (BitLen32 x) @@ -13195,7 +13250,7 @@ func rewriteValueARM_OpBitLen32(v *Value) bool { return true } } -func rewriteValueARM_OpBswap32(v *Value) bool { +func rewriteValueARM_OpBswap32_0(v *Value) bool { b := v.Block _ = b // match: (Bswap32 x) @@ -13242,7 +13297,7 @@ func rewriteValueARM_OpBswap32(v *Value) bool { } return false } -func rewriteValueARM_OpClosureCall(v *Value) bool { +func rewriteValueARM_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -13259,7 +13314,7 @@ func rewriteValueARM_OpClosureCall(v *Value) bool { return true } } -func rewriteValueARM_OpCom16(v *Value) bool { +func rewriteValueARM_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (MVN x) @@ -13270,7 +13325,7 @@ func rewriteValueARM_OpCom16(v *Value) bool { return true } } -func rewriteValueARM_OpCom32(v *Value) bool { +func rewriteValueARM_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (MVN x) @@ -13281,7 +13336,7 @@ func rewriteValueARM_OpCom32(v *Value) bool { return true } } -func rewriteValueARM_OpCom8(v *Value) bool { +func rewriteValueARM_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (MVN x) @@ -13292,7 +13347,7 @@ func rewriteValueARM_OpCom8(v *Value) bool { return true } } -func rewriteValueARM_OpConst16(v *Value) bool { +func rewriteValueARM_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVWconst [val]) @@ -13303,7 +13358,7 @@ func rewriteValueARM_OpConst16(v *Value) bool { return true } } -func rewriteValueARM_OpConst32(v *Value) bool { +func rewriteValueARM_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVWconst [val]) @@ -13314,7 +13369,7 @@ func rewriteValueARM_OpConst32(v *Value) bool { return true } } -func rewriteValueARM_OpConst32F(v *Value) bool { +func rewriteValueARM_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -13325,7 +13380,7 @@ func rewriteValueARM_OpConst32F(v *Value) bool { return true } } -func rewriteValueARM_OpConst64F(v *Value) bool { +func rewriteValueARM_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -13336,7 +13391,7 @@ func rewriteValueARM_OpConst64F(v *Value) bool { return true } } -func rewriteValueARM_OpConst8(v *Value) bool { +func rewriteValueARM_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVWconst [val]) @@ -13347,7 +13402,7 @@ func rewriteValueARM_OpConst8(v *Value) bool { return true } } -func rewriteValueARM_OpConstBool(v *Value) bool { +func rewriteValueARM_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVWconst [b]) @@ -13358,7 +13413,7 @@ func rewriteValueARM_OpConstBool(v *Value) bool { return true } } -func rewriteValueARM_OpConstNil(v *Value) bool { +func rewriteValueARM_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVWconst [0]) @@ -13368,7 +13423,7 @@ func rewriteValueARM_OpConstNil(v *Value) bool { return true } } -func rewriteValueARM_OpConvert(v *Value) bool { +func rewriteValueARM_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVWconvert x mem) @@ -13381,7 +13436,7 @@ func rewriteValueARM_OpConvert(v *Value) bool { return true } } -func rewriteValueARM_OpCtz32(v *Value) bool { +func rewriteValueARM_OpCtz32_0(v *Value) bool { b := v.Block _ = b // match: (Ctz32 x) @@ -13427,7 +13482,7 @@ func rewriteValueARM_OpCtz32(v *Value) bool { } return false } -func rewriteValueARM_OpCvt32Fto32(v *Value) bool { +func rewriteValueARM_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (MOVFW x) @@ -13438,7 +13493,7 @@ func rewriteValueARM_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32Fto32U(v *Value) bool { +func rewriteValueARM_OpCvt32Fto32U_0(v *Value) bool { // match: (Cvt32Fto32U x) // cond: // result: (MOVFWU x) @@ -13449,7 +13504,7 @@ func rewriteValueARM_OpCvt32Fto32U(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32Fto64F(v *Value) bool { +func rewriteValueARM_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -13460,7 +13515,7 @@ func rewriteValueARM_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32Uto32F(v *Value) bool { +func rewriteValueARM_OpCvt32Uto32F_0(v *Value) bool { // match: (Cvt32Uto32F x) // cond: // result: (MOVWUF x) @@ -13471,7 +13526,7 @@ func rewriteValueARM_OpCvt32Uto32F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32Uto64F(v *Value) bool { +func rewriteValueARM_OpCvt32Uto64F_0(v *Value) bool { // match: (Cvt32Uto64F x) // cond: // result: (MOVWUD x) @@ -13482,7 +13537,7 @@ func rewriteValueARM_OpCvt32Uto64F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32to32F(v *Value) bool { +func rewriteValueARM_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -13493,7 +13548,7 @@ func rewriteValueARM_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt32to64F(v *Value) bool { +func rewriteValueARM_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -13504,7 +13559,7 @@ func rewriteValueARM_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt64Fto32(v *Value) bool { +func rewriteValueARM_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (MOVDW x) @@ -13515,7 +13570,7 @@ func rewriteValueARM_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueARM_OpCvt64Fto32F(v *Value) bool { +func rewriteValueARM_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -13526,7 +13581,7 @@ func rewriteValueARM_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueARM_OpCvt64Fto32U(v *Value) bool { +func rewriteValueARM_OpCvt64Fto32U_0(v *Value) bool { // match: (Cvt64Fto32U x) // cond: // result: (MOVDWU x) @@ -13537,7 +13592,7 @@ func rewriteValueARM_OpCvt64Fto32U(v *Value) bool { return true } } -func rewriteValueARM_OpDiv16(v *Value) bool { +func rewriteValueARM_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13558,7 +13613,7 @@ func rewriteValueARM_OpDiv16(v *Value) bool { return true } } -func rewriteValueARM_OpDiv16u(v *Value) bool { +func rewriteValueARM_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13579,7 +13634,7 @@ func rewriteValueARM_OpDiv16u(v *Value) bool { return true } } -func rewriteValueARM_OpDiv32(v *Value) bool { +func rewriteValueARM_OpDiv32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13634,7 +13689,7 @@ func rewriteValueARM_OpDiv32(v *Value) bool { return true } } -func rewriteValueARM_OpDiv32F(v *Value) bool { +func rewriteValueARM_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -13647,7 +13702,7 @@ func rewriteValueARM_OpDiv32F(v *Value) bool { return true } } -func rewriteValueARM_OpDiv32u(v *Value) bool { +func rewriteValueARM_OpDiv32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13667,7 +13722,7 @@ func rewriteValueARM_OpDiv32u(v *Value) bool { return true } } -func rewriteValueARM_OpDiv64F(v *Value) bool { +func rewriteValueARM_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -13680,7 +13735,7 @@ func rewriteValueARM_OpDiv64F(v *Value) bool { return true } } -func rewriteValueARM_OpDiv8(v *Value) bool { +func rewriteValueARM_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13701,7 +13756,7 @@ func rewriteValueARM_OpDiv8(v *Value) bool { return true } } -func rewriteValueARM_OpDiv8u(v *Value) bool { +func rewriteValueARM_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13722,7 +13777,7 @@ func rewriteValueARM_OpDiv8u(v *Value) bool { return true } } -func rewriteValueARM_OpEq16(v *Value) bool { +func rewriteValueARM_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13745,7 +13800,7 @@ func rewriteValueARM_OpEq16(v *Value) bool { return true } } -func rewriteValueARM_OpEq32(v *Value) bool { +func rewriteValueARM_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -13762,7 +13817,7 @@ func rewriteValueARM_OpEq32(v *Value) bool { return true } } -func rewriteValueARM_OpEq32F(v *Value) bool { +func rewriteValueARM_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -13779,7 +13834,7 @@ func rewriteValueARM_OpEq32F(v *Value) bool { return true } } -func rewriteValueARM_OpEq64F(v *Value) bool { +func rewriteValueARM_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -13796,7 +13851,7 @@ func rewriteValueARM_OpEq64F(v *Value) bool { return true } } -func rewriteValueARM_OpEq8(v *Value) bool { +func rewriteValueARM_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13819,7 +13874,7 @@ func rewriteValueARM_OpEq8(v *Value) bool { return true } } -func rewriteValueARM_OpEqB(v *Value) bool { +func rewriteValueARM_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13839,7 +13894,7 @@ func rewriteValueARM_OpEqB(v *Value) bool { return true } } -func rewriteValueARM_OpEqPtr(v *Value) bool { +func rewriteValueARM_OpEqPtr_0(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -13856,7 +13911,7 @@ func rewriteValueARM_OpEqPtr(v *Value) bool { return true } } -func rewriteValueARM_OpGeq16(v *Value) bool { +func rewriteValueARM_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13879,7 +13934,7 @@ func rewriteValueARM_OpGeq16(v *Value) bool { return true } } -func rewriteValueARM_OpGeq16U(v *Value) bool { +func rewriteValueARM_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13902,7 +13957,7 @@ func rewriteValueARM_OpGeq16U(v *Value) bool { return true } } -func rewriteValueARM_OpGeq32(v *Value) bool { +func rewriteValueARM_OpGeq32_0(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -13919,7 +13974,7 @@ func rewriteValueARM_OpGeq32(v *Value) bool { return true } } -func rewriteValueARM_OpGeq32F(v *Value) bool { +func rewriteValueARM_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -13936,7 +13991,7 @@ func rewriteValueARM_OpGeq32F(v *Value) bool { return true } } -func rewriteValueARM_OpGeq32U(v *Value) bool { +func rewriteValueARM_OpGeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -13953,7 +14008,7 @@ func rewriteValueARM_OpGeq32U(v *Value) bool { return true } } -func rewriteValueARM_OpGeq64F(v *Value) bool { +func rewriteValueARM_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -13970,7 +14025,7 @@ func rewriteValueARM_OpGeq64F(v *Value) bool { return true } } -func rewriteValueARM_OpGeq8(v *Value) bool { +func rewriteValueARM_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13993,7 +14048,7 @@ func rewriteValueARM_OpGeq8(v *Value) bool { return true } } -func rewriteValueARM_OpGeq8U(v *Value) bool { +func rewriteValueARM_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14016,7 +14071,7 @@ func rewriteValueARM_OpGeq8U(v *Value) bool { return true } } -func rewriteValueARM_OpGetClosurePtr(v *Value) bool { +func rewriteValueARM_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -14025,7 +14080,7 @@ func rewriteValueARM_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueARM_OpGreater16(v *Value) bool { +func rewriteValueARM_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14048,7 +14103,7 @@ func rewriteValueARM_OpGreater16(v *Value) bool { return true } } -func rewriteValueARM_OpGreater16U(v *Value) bool { +func rewriteValueARM_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14071,7 +14126,7 @@ func rewriteValueARM_OpGreater16U(v *Value) bool { return true } } -func rewriteValueARM_OpGreater32(v *Value) bool { +func rewriteValueARM_OpGreater32_0(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -14088,7 +14143,7 @@ func rewriteValueARM_OpGreater32(v *Value) bool { return true } } -func rewriteValueARM_OpGreater32F(v *Value) bool { +func rewriteValueARM_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -14105,7 +14160,7 @@ func rewriteValueARM_OpGreater32F(v *Value) bool { return true } } -func rewriteValueARM_OpGreater32U(v *Value) bool { +func rewriteValueARM_OpGreater32U_0(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -14122,7 +14177,7 @@ func rewriteValueARM_OpGreater32U(v *Value) bool { return true } } -func rewriteValueARM_OpGreater64F(v *Value) bool { +func rewriteValueARM_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -14139,7 +14194,7 @@ func rewriteValueARM_OpGreater64F(v *Value) bool { return true } } -func rewriteValueARM_OpGreater8(v *Value) bool { +func rewriteValueARM_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14162,7 +14217,7 @@ func rewriteValueARM_OpGreater8(v *Value) bool { return true } } -func rewriteValueARM_OpGreater8U(v *Value) bool { +func rewriteValueARM_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14185,7 +14240,7 @@ func rewriteValueARM_OpGreater8U(v *Value) bool { return true } } -func rewriteValueARM_OpHmul32(v *Value) bool { +func rewriteValueARM_OpHmul32_0(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (HMUL x y) @@ -14198,7 +14253,7 @@ func rewriteValueARM_OpHmul32(v *Value) bool { return true } } -func rewriteValueARM_OpHmul32u(v *Value) bool { +func rewriteValueARM_OpHmul32u_0(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (HMULU x y) @@ -14211,7 +14266,7 @@ func rewriteValueARM_OpHmul32u(v *Value) bool { return true } } -func rewriteValueARM_OpInterCall(v *Value) bool { +func rewriteValueARM_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -14226,7 +14281,7 @@ func rewriteValueARM_OpInterCall(v *Value) bool { return true } } -func rewriteValueARM_OpIsInBounds(v *Value) bool { +func rewriteValueARM_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -14243,7 +14298,7 @@ func rewriteValueARM_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueARM_OpIsNonNil(v *Value) bool { +func rewriteValueARM_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -14259,7 +14314,7 @@ func rewriteValueARM_OpIsNonNil(v *Value) bool { return true } } -func rewriteValueARM_OpIsSliceInBounds(v *Value) bool { +func rewriteValueARM_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -14276,7 +14331,7 @@ func rewriteValueARM_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueARM_OpLeq16(v *Value) bool { +func rewriteValueARM_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14299,7 +14354,7 @@ func rewriteValueARM_OpLeq16(v *Value) bool { return true } } -func rewriteValueARM_OpLeq16U(v *Value) bool { +func rewriteValueARM_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14322,7 +14377,7 @@ func rewriteValueARM_OpLeq16U(v *Value) bool { return true } } -func rewriteValueARM_OpLeq32(v *Value) bool { +func rewriteValueARM_OpLeq32_0(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -14339,7 +14394,7 @@ func rewriteValueARM_OpLeq32(v *Value) bool { return true } } -func rewriteValueARM_OpLeq32F(v *Value) bool { +func rewriteValueARM_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -14356,7 +14411,7 @@ func rewriteValueARM_OpLeq32F(v *Value) bool { return true } } -func rewriteValueARM_OpLeq32U(v *Value) bool { +func rewriteValueARM_OpLeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -14373,7 +14428,7 @@ func rewriteValueARM_OpLeq32U(v *Value) bool { return true } } -func rewriteValueARM_OpLeq64F(v *Value) bool { +func rewriteValueARM_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -14390,7 +14445,7 @@ func rewriteValueARM_OpLeq64F(v *Value) bool { return true } } -func rewriteValueARM_OpLeq8(v *Value) bool { +func rewriteValueARM_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14413,7 +14468,7 @@ func rewriteValueARM_OpLeq8(v *Value) bool { return true } } -func rewriteValueARM_OpLeq8U(v *Value) bool { +func rewriteValueARM_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14436,7 +14491,7 @@ func rewriteValueARM_OpLeq8U(v *Value) bool { return true } } -func rewriteValueARM_OpLess16(v *Value) bool { +func rewriteValueARM_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14459,7 +14514,7 @@ func rewriteValueARM_OpLess16(v *Value) bool { return true } } -func rewriteValueARM_OpLess16U(v *Value) bool { +func rewriteValueARM_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14482,7 +14537,7 @@ func rewriteValueARM_OpLess16U(v *Value) bool { return true } } -func rewriteValueARM_OpLess32(v *Value) bool { +func rewriteValueARM_OpLess32_0(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -14499,7 +14554,7 @@ func rewriteValueARM_OpLess32(v *Value) bool { return true } } -func rewriteValueARM_OpLess32F(v *Value) bool { +func rewriteValueARM_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -14516,7 +14571,7 @@ func rewriteValueARM_OpLess32F(v *Value) bool { return true } } -func rewriteValueARM_OpLess32U(v *Value) bool { +func rewriteValueARM_OpLess32U_0(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -14533,7 +14588,7 @@ func rewriteValueARM_OpLess32U(v *Value) bool { return true } } -func rewriteValueARM_OpLess64F(v *Value) bool { +func rewriteValueARM_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -14550,7 +14605,7 @@ func rewriteValueARM_OpLess64F(v *Value) bool { return true } } -func rewriteValueARM_OpLess8(v *Value) bool { +func rewriteValueARM_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14573,7 +14628,7 @@ func rewriteValueARM_OpLess8(v *Value) bool { return true } } -func rewriteValueARM_OpLess8U(v *Value) bool { +func rewriteValueARM_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14596,7 +14651,7 @@ func rewriteValueARM_OpLess8U(v *Value) bool { return true } } -func rewriteValueARM_OpLoad(v *Value) bool { +func rewriteValueARM_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -14719,7 +14774,7 @@ func rewriteValueARM_OpLoad(v *Value) bool { } return false } -func rewriteValueARM_OpLsh16x16(v *Value) bool { +func rewriteValueARM_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14747,7 +14802,7 @@ func rewriteValueARM_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueARM_OpLsh16x32(v *Value) bool { +func rewriteValueARM_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x y) @@ -14769,7 +14824,7 @@ func rewriteValueARM_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueARM_OpLsh16x64(v *Value) bool { +func rewriteValueARM_OpLsh16x64_0(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint64(c) < 16 // result: (SLLconst x [c]) @@ -14806,7 +14861,7 @@ func rewriteValueARM_OpLsh16x64(v *Value) bool { } return false } -func rewriteValueARM_OpLsh16x8(v *Value) bool { +func rewriteValueARM_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14825,7 +14880,7 @@ func rewriteValueARM_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueARM_OpLsh32x16(v *Value) bool { +func rewriteValueARM_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14853,7 +14908,7 @@ func rewriteValueARM_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueARM_OpLsh32x32(v *Value) bool { +func rewriteValueARM_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x y) @@ -14875,7 +14930,7 @@ func rewriteValueARM_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueARM_OpLsh32x64(v *Value) bool { +func rewriteValueARM_OpLsh32x64_0(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SLLconst x [c]) @@ -14912,7 +14967,7 @@ func rewriteValueARM_OpLsh32x64(v *Value) bool { } return false } -func rewriteValueARM_OpLsh32x8(v *Value) bool { +func rewriteValueARM_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14931,7 +14986,7 @@ func rewriteValueARM_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueARM_OpLsh8x16(v *Value) bool { +func rewriteValueARM_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14959,7 +15014,7 @@ func rewriteValueARM_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueARM_OpLsh8x32(v *Value) bool { +func rewriteValueARM_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x y) @@ -14981,7 +15036,7 @@ func rewriteValueARM_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueARM_OpLsh8x64(v *Value) bool { +func rewriteValueARM_OpLsh8x64_0(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint64(c) < 8 // result: (SLLconst x [c]) @@ -15018,7 +15073,7 @@ func rewriteValueARM_OpLsh8x64(v *Value) bool { } return false } -func rewriteValueARM_OpLsh8x8(v *Value) bool { +func rewriteValueARM_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15037,7 +15092,7 @@ func rewriteValueARM_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueARM_OpMod16(v *Value) bool { +func rewriteValueARM_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15058,7 +15113,7 @@ func rewriteValueARM_OpMod16(v *Value) bool { return true } } -func rewriteValueARM_OpMod16u(v *Value) bool { +func rewriteValueARM_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15079,7 +15134,7 @@ func rewriteValueARM_OpMod16u(v *Value) bool { return true } } -func rewriteValueARM_OpMod32(v *Value) bool { +func rewriteValueARM_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15128,7 +15183,7 @@ func rewriteValueARM_OpMod32(v *Value) bool { return true } } -func rewriteValueARM_OpMod32u(v *Value) bool { +func rewriteValueARM_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15148,7 +15203,7 @@ func rewriteValueARM_OpMod32u(v *Value) bool { return true } } -func rewriteValueARM_OpMod8(v *Value) bool { +func rewriteValueARM_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15169,7 +15224,7 @@ func rewriteValueARM_OpMod8(v *Value) bool { return true } } -func rewriteValueARM_OpMod8u(v *Value) bool { +func rewriteValueARM_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15190,7 +15245,7 @@ func rewriteValueARM_OpMod8u(v *Value) bool { return true } } -func rewriteValueARM_OpMove(v *Value) bool { +func rewriteValueARM_OpMove_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -15462,7 +15517,7 @@ func rewriteValueARM_OpMove(v *Value) bool { } return false } -func rewriteValueARM_OpMul16(v *Value) bool { +func rewriteValueARM_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MUL x y) @@ -15475,7 +15530,7 @@ func rewriteValueARM_OpMul16(v *Value) bool { return true } } -func rewriteValueARM_OpMul32(v *Value) bool { +func rewriteValueARM_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MUL x y) @@ -15488,7 +15543,7 @@ func rewriteValueARM_OpMul32(v *Value) bool { return true } } -func rewriteValueARM_OpMul32F(v *Value) bool { +func rewriteValueARM_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -15501,7 +15556,7 @@ func rewriteValueARM_OpMul32F(v *Value) bool { return true } } -func rewriteValueARM_OpMul32uhilo(v *Value) bool { +func rewriteValueARM_OpMul32uhilo_0(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULLU x y) @@ -15514,7 +15569,7 @@ func rewriteValueARM_OpMul32uhilo(v *Value) bool { return true } } -func rewriteValueARM_OpMul64F(v *Value) bool { +func rewriteValueARM_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -15527,7 +15582,7 @@ func rewriteValueARM_OpMul64F(v *Value) bool { return true } } -func rewriteValueARM_OpMul8(v *Value) bool { +func rewriteValueARM_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MUL x y) @@ -15540,7 +15595,7 @@ func rewriteValueARM_OpMul8(v *Value) bool { return true } } -func rewriteValueARM_OpNeg16(v *Value) bool { +func rewriteValueARM_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (RSBconst [0] x) @@ -15552,7 +15607,7 @@ func rewriteValueARM_OpNeg16(v *Value) bool { return true } } -func rewriteValueARM_OpNeg32(v *Value) bool { +func rewriteValueARM_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (RSBconst [0] x) @@ -15564,7 +15619,7 @@ func rewriteValueARM_OpNeg32(v *Value) bool { return true } } -func rewriteValueARM_OpNeg32F(v *Value) bool { +func rewriteValueARM_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -15575,7 +15630,7 @@ func rewriteValueARM_OpNeg32F(v *Value) bool { return true } } -func rewriteValueARM_OpNeg64F(v *Value) bool { +func rewriteValueARM_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -15586,7 +15641,7 @@ func rewriteValueARM_OpNeg64F(v *Value) bool { return true } } -func rewriteValueARM_OpNeg8(v *Value) bool { +func rewriteValueARM_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (RSBconst [0] x) @@ -15598,7 +15653,7 @@ func rewriteValueARM_OpNeg8(v *Value) bool { return true } } -func rewriteValueARM_OpNeq16(v *Value) bool { +func rewriteValueARM_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15621,7 +15676,7 @@ func rewriteValueARM_OpNeq16(v *Value) bool { return true } } -func rewriteValueARM_OpNeq32(v *Value) bool { +func rewriteValueARM_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -15638,7 +15693,7 @@ func rewriteValueARM_OpNeq32(v *Value) bool { return true } } -func rewriteValueARM_OpNeq32F(v *Value) bool { +func rewriteValueARM_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -15655,7 +15710,7 @@ func rewriteValueARM_OpNeq32F(v *Value) bool { return true } } -func rewriteValueARM_OpNeq64F(v *Value) bool { +func rewriteValueARM_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -15672,7 +15727,7 @@ func rewriteValueARM_OpNeq64F(v *Value) bool { return true } } -func rewriteValueARM_OpNeq8(v *Value) bool { +func rewriteValueARM_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15695,7 +15750,7 @@ func rewriteValueARM_OpNeq8(v *Value) bool { return true } } -func rewriteValueARM_OpNeqB(v *Value) bool { +func rewriteValueARM_OpNeqB_0(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -15708,7 +15763,7 @@ func rewriteValueARM_OpNeqB(v *Value) bool { return true } } -func rewriteValueARM_OpNeqPtr(v *Value) bool { +func rewriteValueARM_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -15725,7 +15780,7 @@ func rewriteValueARM_OpNeqPtr(v *Value) bool { return true } } -func rewriteValueARM_OpNilCheck(v *Value) bool { +func rewriteValueARM_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -15738,7 +15793,7 @@ func rewriteValueARM_OpNilCheck(v *Value) bool { return true } } -func rewriteValueARM_OpNot(v *Value) bool { +func rewriteValueARM_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -15750,7 +15805,7 @@ func rewriteValueARM_OpNot(v *Value) bool { return true } } -func rewriteValueARM_OpOffPtr(v *Value) bool { +func rewriteValueARM_OpOffPtr_0(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVWaddr [off] ptr) @@ -15777,7 +15832,7 @@ func rewriteValueARM_OpOffPtr(v *Value) bool { return true } } -func rewriteValueARM_OpOr16(v *Value) bool { +func rewriteValueARM_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -15790,7 +15845,7 @@ func rewriteValueARM_OpOr16(v *Value) bool { return true } } -func rewriteValueARM_OpOr32(v *Value) bool { +func rewriteValueARM_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -15803,7 +15858,7 @@ func rewriteValueARM_OpOr32(v *Value) bool { return true } } -func rewriteValueARM_OpOr8(v *Value) bool { +func rewriteValueARM_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -15816,7 +15871,7 @@ func rewriteValueARM_OpOr8(v *Value) bool { return true } } -func rewriteValueARM_OpOrB(v *Value) bool { +func rewriteValueARM_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -15829,7 +15884,7 @@ func rewriteValueARM_OpOrB(v *Value) bool { return true } } -func rewriteValueARM_OpRound32F(v *Value) bool { +func rewriteValueARM_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -15841,7 +15896,7 @@ func rewriteValueARM_OpRound32F(v *Value) bool { return true } } -func rewriteValueARM_OpRound64F(v *Value) bool { +func rewriteValueARM_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -15853,7 +15908,7 @@ func rewriteValueARM_OpRound64F(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16Ux16(v *Value) bool { +func rewriteValueARM_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15883,7 +15938,7 @@ func rewriteValueARM_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16Ux32(v *Value) bool { +func rewriteValueARM_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15909,7 +15964,7 @@ func rewriteValueARM_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16Ux64(v *Value) bool { +func rewriteValueARM_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15953,7 +16008,7 @@ func rewriteValueARM_OpRsh16Ux64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh16Ux8(v *Value) bool { +func rewriteValueARM_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -15974,7 +16029,7 @@ func rewriteValueARM_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16x16(v *Value) bool { +func rewriteValueARM_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16001,7 +16056,7 @@ func rewriteValueARM_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16x32(v *Value) bool { +func rewriteValueARM_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16024,7 +16079,7 @@ func rewriteValueARM_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh16x64(v *Value) bool { +func rewriteValueARM_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16073,7 +16128,7 @@ func rewriteValueARM_OpRsh16x64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh16x8(v *Value) bool { +func rewriteValueARM_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16094,7 +16149,7 @@ func rewriteValueARM_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32Ux16(v *Value) bool { +func rewriteValueARM_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16122,7 +16177,7 @@ func rewriteValueARM_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32Ux32(v *Value) bool { +func rewriteValueARM_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x y) @@ -16144,7 +16199,7 @@ func rewriteValueARM_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32Ux64(v *Value) bool { +func rewriteValueARM_OpRsh32Ux64_0(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRLconst x [c]) @@ -16181,7 +16236,7 @@ func rewriteValueARM_OpRsh32Ux64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh32Ux8(v *Value) bool { +func rewriteValueARM_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16200,7 +16255,7 @@ func rewriteValueARM_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32x16(v *Value) bool { +func rewriteValueARM_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16225,7 +16280,7 @@ func rewriteValueARM_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32x32(v *Value) bool { +func rewriteValueARM_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x y) @@ -16244,7 +16299,7 @@ func rewriteValueARM_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh32x64(v *Value) bool { +func rewriteValueARM_OpRsh32x64_0(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint64(c) < 32 // result: (SRAconst x [c]) @@ -16283,7 +16338,7 @@ func rewriteValueARM_OpRsh32x64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh32x8(v *Value) bool { +func rewriteValueARM_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16302,7 +16357,7 @@ func rewriteValueARM_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8Ux16(v *Value) bool { +func rewriteValueARM_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16332,7 +16387,7 @@ func rewriteValueARM_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8Ux32(v *Value) bool { +func rewriteValueARM_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16358,7 +16413,7 @@ func rewriteValueARM_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8Ux64(v *Value) bool { +func rewriteValueARM_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16402,7 +16457,7 @@ func rewriteValueARM_OpRsh8Ux64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh8Ux8(v *Value) bool { +func rewriteValueARM_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16423,7 +16478,7 @@ func rewriteValueARM_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8x16(v *Value) bool { +func rewriteValueARM_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16450,7 +16505,7 @@ func rewriteValueARM_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8x32(v *Value) bool { +func rewriteValueARM_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16473,7 +16528,7 @@ func rewriteValueARM_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueARM_OpRsh8x64(v *Value) bool { +func rewriteValueARM_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16522,7 +16577,7 @@ func rewriteValueARM_OpRsh8x64(v *Value) bool { } return false } -func rewriteValueARM_OpRsh8x8(v *Value) bool { +func rewriteValueARM_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -16543,7 +16598,7 @@ func rewriteValueARM_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueARM_OpSelect0(v *Value) bool { +func rewriteValueARM_OpSelect0_0(v *Value) bool { // match: (Select0 (CALLudiv x (MOVWconst [1]))) // cond: // result: x @@ -16611,7 +16666,7 @@ func rewriteValueARM_OpSelect0(v *Value) bool { } return false } -func rewriteValueARM_OpSelect1(v *Value) bool { +func rewriteValueARM_OpSelect1_0(v *Value) bool { // match: (Select1 (CALLudiv _ (MOVWconst [1]))) // cond: // result: (MOVWconst [0]) @@ -16677,7 +16732,7 @@ func rewriteValueARM_OpSelect1(v *Value) bool { } return false } -func rewriteValueARM_OpSignExt16to32(v *Value) bool { +func rewriteValueARM_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -16688,7 +16743,7 @@ func rewriteValueARM_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueARM_OpSignExt8to16(v *Value) bool { +func rewriteValueARM_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -16699,7 +16754,7 @@ func rewriteValueARM_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueARM_OpSignExt8to32(v *Value) bool { +func rewriteValueARM_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -16710,7 +16765,7 @@ func rewriteValueARM_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueARM_OpSignmask(v *Value) bool { +func rewriteValueARM_OpSignmask_0(v *Value) bool { // match: (Signmask x) // cond: // result: (SRAconst x [31]) @@ -16722,7 +16777,7 @@ func rewriteValueARM_OpSignmask(v *Value) bool { return true } } -func rewriteValueARM_OpSlicemask(v *Value) bool { +func rewriteValueARM_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -16740,7 +16795,7 @@ func rewriteValueARM_OpSlicemask(v *Value) bool { return true } } -func rewriteValueARM_OpSqrt(v *Value) bool { +func rewriteValueARM_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTD x) @@ -16751,7 +16806,7 @@ func rewriteValueARM_OpSqrt(v *Value) bool { return true } } -func rewriteValueARM_OpStaticCall(v *Value) bool { +func rewriteValueARM_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -16766,7 +16821,7 @@ func rewriteValueARM_OpStaticCall(v *Value) bool { return true } } -func rewriteValueARM_OpStore(v *Value) bool { +func rewriteValueARM_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -16854,7 +16909,7 @@ func rewriteValueARM_OpStore(v *Value) bool { } return false } -func rewriteValueARM_OpSub16(v *Value) bool { +func rewriteValueARM_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -16867,7 +16922,7 @@ func rewriteValueARM_OpSub16(v *Value) bool { return true } } -func rewriteValueARM_OpSub32(v *Value) bool { +func rewriteValueARM_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -16880,7 +16935,7 @@ func rewriteValueARM_OpSub32(v *Value) bool { return true } } -func rewriteValueARM_OpSub32F(v *Value) bool { +func rewriteValueARM_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -16893,7 +16948,7 @@ func rewriteValueARM_OpSub32F(v *Value) bool { return true } } -func rewriteValueARM_OpSub32carry(v *Value) bool { +func rewriteValueARM_OpSub32carry_0(v *Value) bool { // match: (Sub32carry x y) // cond: // result: (SUBS x y) @@ -16906,7 +16961,7 @@ func rewriteValueARM_OpSub32carry(v *Value) bool { return true } } -func rewriteValueARM_OpSub32withcarry(v *Value) bool { +func rewriteValueARM_OpSub32withcarry_0(v *Value) bool { // match: (Sub32withcarry x y c) // cond: // result: (SBC x y c) @@ -16921,7 +16976,7 @@ func rewriteValueARM_OpSub32withcarry(v *Value) bool { return true } } -func rewriteValueARM_OpSub64F(v *Value) bool { +func rewriteValueARM_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -16934,7 +16989,7 @@ func rewriteValueARM_OpSub64F(v *Value) bool { return true } } -func rewriteValueARM_OpSub8(v *Value) bool { +func rewriteValueARM_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -16947,7 +17002,7 @@ func rewriteValueARM_OpSub8(v *Value) bool { return true } } -func rewriteValueARM_OpSubPtr(v *Value) bool { +func rewriteValueARM_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -16960,7 +17015,7 @@ func rewriteValueARM_OpSubPtr(v *Value) bool { return true } } -func rewriteValueARM_OpTrunc16to8(v *Value) bool { +func rewriteValueARM_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -16972,7 +17027,7 @@ func rewriteValueARM_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueARM_OpTrunc32to16(v *Value) bool { +func rewriteValueARM_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -16984,7 +17039,7 @@ func rewriteValueARM_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueARM_OpTrunc32to8(v *Value) bool { +func rewriteValueARM_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -16996,7 +17051,7 @@ func rewriteValueARM_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueARM_OpXor16(v *Value) bool { +func rewriteValueARM_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -17009,7 +17064,7 @@ func rewriteValueARM_OpXor16(v *Value) bool { return true } } -func rewriteValueARM_OpXor32(v *Value) bool { +func rewriteValueARM_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -17022,7 +17077,7 @@ func rewriteValueARM_OpXor32(v *Value) bool { return true } } -func rewriteValueARM_OpXor8(v *Value) bool { +func rewriteValueARM_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -17035,7 +17090,7 @@ func rewriteValueARM_OpXor8(v *Value) bool { return true } } -func rewriteValueARM_OpZero(v *Value) bool { +func rewriteValueARM_OpZero_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -17285,7 +17340,7 @@ func rewriteValueARM_OpZero(v *Value) bool { } return false } -func rewriteValueARM_OpZeroExt16to32(v *Value) bool { +func rewriteValueARM_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -17296,7 +17351,7 @@ func rewriteValueARM_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueARM_OpZeroExt8to16(v *Value) bool { +func rewriteValueARM_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -17307,7 +17362,7 @@ func rewriteValueARM_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueARM_OpZeroExt8to32(v *Value) bool { +func rewriteValueARM_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -17318,7 +17373,7 @@ func rewriteValueARM_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueARM_OpZeromask(v *Value) bool { +func rewriteValueARM_OpZeromask_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types diff --git a/src/cmd/compile/internal/ssa/rewriteARM64.go b/src/cmd/compile/internal/ssa/rewriteARM64.go index 56f5ab5ac0..684961b1dd 100644 --- a/src/cmd/compile/internal/ssa/rewriteARM64.go +++ b/src/cmd/compile/internal/ssa/rewriteARM64.go @@ -14,711 +14,711 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueARM64(v *Value) bool { switch v.Op { case OpARM64ADD: - return rewriteValueARM64_OpARM64ADD(v) + return rewriteValueARM64_OpARM64ADD_0(v) case OpARM64ADDconst: - return rewriteValueARM64_OpARM64ADDconst(v) + return rewriteValueARM64_OpARM64ADDconst_0(v) case OpARM64ADDshiftLL: - return rewriteValueARM64_OpARM64ADDshiftLL(v) + return rewriteValueARM64_OpARM64ADDshiftLL_0(v) case OpARM64ADDshiftRA: - return rewriteValueARM64_OpARM64ADDshiftRA(v) + return rewriteValueARM64_OpARM64ADDshiftRA_0(v) case OpARM64ADDshiftRL: - return rewriteValueARM64_OpARM64ADDshiftRL(v) + return rewriteValueARM64_OpARM64ADDshiftRL_0(v) case OpARM64AND: - return rewriteValueARM64_OpARM64AND(v) + return rewriteValueARM64_OpARM64AND_0(v) || rewriteValueARM64_OpARM64AND_10(v) case OpARM64ANDconst: - return rewriteValueARM64_OpARM64ANDconst(v) + return rewriteValueARM64_OpARM64ANDconst_0(v) case OpARM64ANDshiftLL: - return rewriteValueARM64_OpARM64ANDshiftLL(v) + return rewriteValueARM64_OpARM64ANDshiftLL_0(v) case OpARM64ANDshiftRA: - return rewriteValueARM64_OpARM64ANDshiftRA(v) + return rewriteValueARM64_OpARM64ANDshiftRA_0(v) case OpARM64ANDshiftRL: - return rewriteValueARM64_OpARM64ANDshiftRL(v) + return rewriteValueARM64_OpARM64ANDshiftRL_0(v) case OpARM64BIC: - return rewriteValueARM64_OpARM64BIC(v) + return rewriteValueARM64_OpARM64BIC_0(v) case OpARM64BICconst: - return rewriteValueARM64_OpARM64BICconst(v) + return rewriteValueARM64_OpARM64BICconst_0(v) case OpARM64BICshiftLL: - return rewriteValueARM64_OpARM64BICshiftLL(v) + return rewriteValueARM64_OpARM64BICshiftLL_0(v) case OpARM64BICshiftRA: - return rewriteValueARM64_OpARM64BICshiftRA(v) + return rewriteValueARM64_OpARM64BICshiftRA_0(v) case OpARM64BICshiftRL: - return rewriteValueARM64_OpARM64BICshiftRL(v) + return rewriteValueARM64_OpARM64BICshiftRL_0(v) case OpARM64CMP: - return rewriteValueARM64_OpARM64CMP(v) + return rewriteValueARM64_OpARM64CMP_0(v) case OpARM64CMPW: - return rewriteValueARM64_OpARM64CMPW(v) + return rewriteValueARM64_OpARM64CMPW_0(v) case OpARM64CMPWconst: - return rewriteValueARM64_OpARM64CMPWconst(v) + return rewriteValueARM64_OpARM64CMPWconst_0(v) case OpARM64CMPconst: - return rewriteValueARM64_OpARM64CMPconst(v) + return rewriteValueARM64_OpARM64CMPconst_0(v) case OpARM64CMPshiftLL: - return rewriteValueARM64_OpARM64CMPshiftLL(v) + return rewriteValueARM64_OpARM64CMPshiftLL_0(v) case OpARM64CMPshiftRA: - return rewriteValueARM64_OpARM64CMPshiftRA(v) + return rewriteValueARM64_OpARM64CMPshiftRA_0(v) case OpARM64CMPshiftRL: - return rewriteValueARM64_OpARM64CMPshiftRL(v) + return rewriteValueARM64_OpARM64CMPshiftRL_0(v) case OpARM64CSELULT: - return rewriteValueARM64_OpARM64CSELULT(v) + return rewriteValueARM64_OpARM64CSELULT_0(v) case OpARM64CSELULT0: - return rewriteValueARM64_OpARM64CSELULT0(v) + return rewriteValueARM64_OpARM64CSELULT0_0(v) case OpARM64DIV: - return rewriteValueARM64_OpARM64DIV(v) + return rewriteValueARM64_OpARM64DIV_0(v) case OpARM64DIVW: - return rewriteValueARM64_OpARM64DIVW(v) + return rewriteValueARM64_OpARM64DIVW_0(v) case OpARM64Equal: - return rewriteValueARM64_OpARM64Equal(v) + return rewriteValueARM64_OpARM64Equal_0(v) case OpARM64FMOVDload: - return rewriteValueARM64_OpARM64FMOVDload(v) + return rewriteValueARM64_OpARM64FMOVDload_0(v) case OpARM64FMOVDstore: - return rewriteValueARM64_OpARM64FMOVDstore(v) + return rewriteValueARM64_OpARM64FMOVDstore_0(v) case OpARM64FMOVSload: - return rewriteValueARM64_OpARM64FMOVSload(v) + return rewriteValueARM64_OpARM64FMOVSload_0(v) case OpARM64FMOVSstore: - return rewriteValueARM64_OpARM64FMOVSstore(v) + return rewriteValueARM64_OpARM64FMOVSstore_0(v) case OpARM64GreaterEqual: - return rewriteValueARM64_OpARM64GreaterEqual(v) + return rewriteValueARM64_OpARM64GreaterEqual_0(v) case OpARM64GreaterEqualU: - return rewriteValueARM64_OpARM64GreaterEqualU(v) + return rewriteValueARM64_OpARM64GreaterEqualU_0(v) case OpARM64GreaterThan: - return rewriteValueARM64_OpARM64GreaterThan(v) + return rewriteValueARM64_OpARM64GreaterThan_0(v) case OpARM64GreaterThanU: - return rewriteValueARM64_OpARM64GreaterThanU(v) + return rewriteValueARM64_OpARM64GreaterThanU_0(v) case OpARM64LessEqual: - return rewriteValueARM64_OpARM64LessEqual(v) + return rewriteValueARM64_OpARM64LessEqual_0(v) case OpARM64LessEqualU: - return rewriteValueARM64_OpARM64LessEqualU(v) + return rewriteValueARM64_OpARM64LessEqualU_0(v) case OpARM64LessThan: - return rewriteValueARM64_OpARM64LessThan(v) + return rewriteValueARM64_OpARM64LessThan_0(v) case OpARM64LessThanU: - return rewriteValueARM64_OpARM64LessThanU(v) + return rewriteValueARM64_OpARM64LessThanU_0(v) case OpARM64MOD: - return rewriteValueARM64_OpARM64MOD(v) + return rewriteValueARM64_OpARM64MOD_0(v) case OpARM64MODW: - return rewriteValueARM64_OpARM64MODW(v) + return rewriteValueARM64_OpARM64MODW_0(v) case OpARM64MOVBUload: - return rewriteValueARM64_OpARM64MOVBUload(v) + return rewriteValueARM64_OpARM64MOVBUload_0(v) case OpARM64MOVBUreg: - return rewriteValueARM64_OpARM64MOVBUreg(v) + return rewriteValueARM64_OpARM64MOVBUreg_0(v) case OpARM64MOVBload: - return rewriteValueARM64_OpARM64MOVBload(v) + return rewriteValueARM64_OpARM64MOVBload_0(v) case OpARM64MOVBreg: - return rewriteValueARM64_OpARM64MOVBreg(v) + return rewriteValueARM64_OpARM64MOVBreg_0(v) case OpARM64MOVBstore: - return rewriteValueARM64_OpARM64MOVBstore(v) + return rewriteValueARM64_OpARM64MOVBstore_0(v) case OpARM64MOVBstorezero: - return rewriteValueARM64_OpARM64MOVBstorezero(v) + return rewriteValueARM64_OpARM64MOVBstorezero_0(v) case OpARM64MOVDload: - return rewriteValueARM64_OpARM64MOVDload(v) + return rewriteValueARM64_OpARM64MOVDload_0(v) case OpARM64MOVDreg: - return rewriteValueARM64_OpARM64MOVDreg(v) + return rewriteValueARM64_OpARM64MOVDreg_0(v) case OpARM64MOVDstore: - return rewriteValueARM64_OpARM64MOVDstore(v) + return rewriteValueARM64_OpARM64MOVDstore_0(v) case OpARM64MOVDstorezero: - return rewriteValueARM64_OpARM64MOVDstorezero(v) + return rewriteValueARM64_OpARM64MOVDstorezero_0(v) case OpARM64MOVHUload: - return rewriteValueARM64_OpARM64MOVHUload(v) + return rewriteValueARM64_OpARM64MOVHUload_0(v) case OpARM64MOVHUreg: - return rewriteValueARM64_OpARM64MOVHUreg(v) + return rewriteValueARM64_OpARM64MOVHUreg_0(v) case OpARM64MOVHload: - return rewriteValueARM64_OpARM64MOVHload(v) + return rewriteValueARM64_OpARM64MOVHload_0(v) case OpARM64MOVHreg: - return rewriteValueARM64_OpARM64MOVHreg(v) + return rewriteValueARM64_OpARM64MOVHreg_0(v) case OpARM64MOVHstore: - return rewriteValueARM64_OpARM64MOVHstore(v) + return rewriteValueARM64_OpARM64MOVHstore_0(v) case OpARM64MOVHstorezero: - return rewriteValueARM64_OpARM64MOVHstorezero(v) + return rewriteValueARM64_OpARM64MOVHstorezero_0(v) case OpARM64MOVWUload: - return rewriteValueARM64_OpARM64MOVWUload(v) + return rewriteValueARM64_OpARM64MOVWUload_0(v) case OpARM64MOVWUreg: - return rewriteValueARM64_OpARM64MOVWUreg(v) + return rewriteValueARM64_OpARM64MOVWUreg_0(v) case OpARM64MOVWload: - return rewriteValueARM64_OpARM64MOVWload(v) + return rewriteValueARM64_OpARM64MOVWload_0(v) case OpARM64MOVWreg: - return rewriteValueARM64_OpARM64MOVWreg(v) + return rewriteValueARM64_OpARM64MOVWreg_0(v) || rewriteValueARM64_OpARM64MOVWreg_10(v) case OpARM64MOVWstore: - return rewriteValueARM64_OpARM64MOVWstore(v) + return rewriteValueARM64_OpARM64MOVWstore_0(v) case OpARM64MOVWstorezero: - return rewriteValueARM64_OpARM64MOVWstorezero(v) + return rewriteValueARM64_OpARM64MOVWstorezero_0(v) case OpARM64MUL: - return rewriteValueARM64_OpARM64MUL(v) + return rewriteValueARM64_OpARM64MUL_0(v) || rewriteValueARM64_OpARM64MUL_10(v) || rewriteValueARM64_OpARM64MUL_20(v) case OpARM64MULW: - return rewriteValueARM64_OpARM64MULW(v) + return rewriteValueARM64_OpARM64MULW_0(v) || rewriteValueARM64_OpARM64MULW_10(v) || rewriteValueARM64_OpARM64MULW_20(v) case OpARM64MVN: - return rewriteValueARM64_OpARM64MVN(v) + return rewriteValueARM64_OpARM64MVN_0(v) case OpARM64NEG: - return rewriteValueARM64_OpARM64NEG(v) + return rewriteValueARM64_OpARM64NEG_0(v) case OpARM64NotEqual: - return rewriteValueARM64_OpARM64NotEqual(v) + return rewriteValueARM64_OpARM64NotEqual_0(v) case OpARM64OR: - return rewriteValueARM64_OpARM64OR(v) + return rewriteValueARM64_OpARM64OR_0(v) || rewriteValueARM64_OpARM64OR_10(v) case OpARM64ORconst: - return rewriteValueARM64_OpARM64ORconst(v) + return rewriteValueARM64_OpARM64ORconst_0(v) case OpARM64ORshiftLL: - return rewriteValueARM64_OpARM64ORshiftLL(v) + return rewriteValueARM64_OpARM64ORshiftLL_0(v) || rewriteValueARM64_OpARM64ORshiftLL_10(v) case OpARM64ORshiftRA: - return rewriteValueARM64_OpARM64ORshiftRA(v) + return rewriteValueARM64_OpARM64ORshiftRA_0(v) case OpARM64ORshiftRL: - return rewriteValueARM64_OpARM64ORshiftRL(v) + return rewriteValueARM64_OpARM64ORshiftRL_0(v) case OpARM64SLL: - return rewriteValueARM64_OpARM64SLL(v) + return rewriteValueARM64_OpARM64SLL_0(v) case OpARM64SLLconst: - return rewriteValueARM64_OpARM64SLLconst(v) + return rewriteValueARM64_OpARM64SLLconst_0(v) case OpARM64SRA: - return rewriteValueARM64_OpARM64SRA(v) + return rewriteValueARM64_OpARM64SRA_0(v) case OpARM64SRAconst: - return rewriteValueARM64_OpARM64SRAconst(v) + return rewriteValueARM64_OpARM64SRAconst_0(v) case OpARM64SRL: - return rewriteValueARM64_OpARM64SRL(v) + return rewriteValueARM64_OpARM64SRL_0(v) case OpARM64SRLconst: - return rewriteValueARM64_OpARM64SRLconst(v) + return rewriteValueARM64_OpARM64SRLconst_0(v) case OpARM64SUB: - return rewriteValueARM64_OpARM64SUB(v) + return rewriteValueARM64_OpARM64SUB_0(v) case OpARM64SUBconst: - return rewriteValueARM64_OpARM64SUBconst(v) + return rewriteValueARM64_OpARM64SUBconst_0(v) case OpARM64SUBshiftLL: - return rewriteValueARM64_OpARM64SUBshiftLL(v) + return rewriteValueARM64_OpARM64SUBshiftLL_0(v) case OpARM64SUBshiftRA: - return rewriteValueARM64_OpARM64SUBshiftRA(v) + return rewriteValueARM64_OpARM64SUBshiftRA_0(v) case OpARM64SUBshiftRL: - return rewriteValueARM64_OpARM64SUBshiftRL(v) + return rewriteValueARM64_OpARM64SUBshiftRL_0(v) case OpARM64UDIV: - return rewriteValueARM64_OpARM64UDIV(v) + return rewriteValueARM64_OpARM64UDIV_0(v) case OpARM64UDIVW: - return rewriteValueARM64_OpARM64UDIVW(v) + return rewriteValueARM64_OpARM64UDIVW_0(v) case OpARM64UMOD: - return rewriteValueARM64_OpARM64UMOD(v) + return rewriteValueARM64_OpARM64UMOD_0(v) case OpARM64UMODW: - return rewriteValueARM64_OpARM64UMODW(v) + return rewriteValueARM64_OpARM64UMODW_0(v) case OpARM64XOR: - return rewriteValueARM64_OpARM64XOR(v) + return rewriteValueARM64_OpARM64XOR_0(v) case OpARM64XORconst: - return rewriteValueARM64_OpARM64XORconst(v) + return rewriteValueARM64_OpARM64XORconst_0(v) case OpARM64XORshiftLL: - return rewriteValueARM64_OpARM64XORshiftLL(v) + return rewriteValueARM64_OpARM64XORshiftLL_0(v) case OpARM64XORshiftRA: - return rewriteValueARM64_OpARM64XORshiftRA(v) + return rewriteValueARM64_OpARM64XORshiftRA_0(v) case OpARM64XORshiftRL: - return rewriteValueARM64_OpARM64XORshiftRL(v) + return rewriteValueARM64_OpARM64XORshiftRL_0(v) case OpAdd16: - return rewriteValueARM64_OpAdd16(v) + return rewriteValueARM64_OpAdd16_0(v) case OpAdd32: - return rewriteValueARM64_OpAdd32(v) + return rewriteValueARM64_OpAdd32_0(v) case OpAdd32F: - return rewriteValueARM64_OpAdd32F(v) + return rewriteValueARM64_OpAdd32F_0(v) case OpAdd64: - return rewriteValueARM64_OpAdd64(v) + return rewriteValueARM64_OpAdd64_0(v) case OpAdd64F: - return rewriteValueARM64_OpAdd64F(v) + return rewriteValueARM64_OpAdd64F_0(v) case OpAdd8: - return rewriteValueARM64_OpAdd8(v) + return rewriteValueARM64_OpAdd8_0(v) case OpAddPtr: - return rewriteValueARM64_OpAddPtr(v) + return rewriteValueARM64_OpAddPtr_0(v) case OpAddr: - return rewriteValueARM64_OpAddr(v) + return rewriteValueARM64_OpAddr_0(v) case OpAnd16: - return rewriteValueARM64_OpAnd16(v) + return rewriteValueARM64_OpAnd16_0(v) case OpAnd32: - return rewriteValueARM64_OpAnd32(v) + return rewriteValueARM64_OpAnd32_0(v) case OpAnd64: - return rewriteValueARM64_OpAnd64(v) + return rewriteValueARM64_OpAnd64_0(v) case OpAnd8: - return rewriteValueARM64_OpAnd8(v) + return rewriteValueARM64_OpAnd8_0(v) case OpAndB: - return rewriteValueARM64_OpAndB(v) + return rewriteValueARM64_OpAndB_0(v) case OpAtomicAdd32: - return rewriteValueARM64_OpAtomicAdd32(v) + return rewriteValueARM64_OpAtomicAdd32_0(v) case OpAtomicAdd64: - return rewriteValueARM64_OpAtomicAdd64(v) + return rewriteValueARM64_OpAtomicAdd64_0(v) case OpAtomicAnd8: - return rewriteValueARM64_OpAtomicAnd8(v) + return rewriteValueARM64_OpAtomicAnd8_0(v) case OpAtomicCompareAndSwap32: - return rewriteValueARM64_OpAtomicCompareAndSwap32(v) + return rewriteValueARM64_OpAtomicCompareAndSwap32_0(v) case OpAtomicCompareAndSwap64: - return rewriteValueARM64_OpAtomicCompareAndSwap64(v) + return rewriteValueARM64_OpAtomicCompareAndSwap64_0(v) case OpAtomicExchange32: - return rewriteValueARM64_OpAtomicExchange32(v) + return rewriteValueARM64_OpAtomicExchange32_0(v) case OpAtomicExchange64: - return rewriteValueARM64_OpAtomicExchange64(v) + return rewriteValueARM64_OpAtomicExchange64_0(v) case OpAtomicLoad32: - return rewriteValueARM64_OpAtomicLoad32(v) + return rewriteValueARM64_OpAtomicLoad32_0(v) case OpAtomicLoad64: - return rewriteValueARM64_OpAtomicLoad64(v) + return rewriteValueARM64_OpAtomicLoad64_0(v) case OpAtomicLoadPtr: - return rewriteValueARM64_OpAtomicLoadPtr(v) + return rewriteValueARM64_OpAtomicLoadPtr_0(v) case OpAtomicOr8: - return rewriteValueARM64_OpAtomicOr8(v) + return rewriteValueARM64_OpAtomicOr8_0(v) case OpAtomicStore32: - return rewriteValueARM64_OpAtomicStore32(v) + return rewriteValueARM64_OpAtomicStore32_0(v) case OpAtomicStore64: - return rewriteValueARM64_OpAtomicStore64(v) + return rewriteValueARM64_OpAtomicStore64_0(v) case OpAtomicStorePtrNoWB: - return rewriteValueARM64_OpAtomicStorePtrNoWB(v) + return rewriteValueARM64_OpAtomicStorePtrNoWB_0(v) case OpAvg64u: - return rewriteValueARM64_OpAvg64u(v) + return rewriteValueARM64_OpAvg64u_0(v) case OpBitLen64: - return rewriteValueARM64_OpBitLen64(v) + return rewriteValueARM64_OpBitLen64_0(v) case OpBitRev16: - return rewriteValueARM64_OpBitRev16(v) + return rewriteValueARM64_OpBitRev16_0(v) case OpBitRev32: - return rewriteValueARM64_OpBitRev32(v) + return rewriteValueARM64_OpBitRev32_0(v) case OpBitRev64: - return rewriteValueARM64_OpBitRev64(v) + return rewriteValueARM64_OpBitRev64_0(v) case OpBitRev8: - return rewriteValueARM64_OpBitRev8(v) + return rewriteValueARM64_OpBitRev8_0(v) case OpBswap32: - return rewriteValueARM64_OpBswap32(v) + return rewriteValueARM64_OpBswap32_0(v) case OpBswap64: - return rewriteValueARM64_OpBswap64(v) + return rewriteValueARM64_OpBswap64_0(v) case OpClosureCall: - return rewriteValueARM64_OpClosureCall(v) + return rewriteValueARM64_OpClosureCall_0(v) case OpCom16: - return rewriteValueARM64_OpCom16(v) + return rewriteValueARM64_OpCom16_0(v) case OpCom32: - return rewriteValueARM64_OpCom32(v) + return rewriteValueARM64_OpCom32_0(v) case OpCom64: - return rewriteValueARM64_OpCom64(v) + return rewriteValueARM64_OpCom64_0(v) case OpCom8: - return rewriteValueARM64_OpCom8(v) + return rewriteValueARM64_OpCom8_0(v) case OpConst16: - return rewriteValueARM64_OpConst16(v) + return rewriteValueARM64_OpConst16_0(v) case OpConst32: - return rewriteValueARM64_OpConst32(v) + return rewriteValueARM64_OpConst32_0(v) case OpConst32F: - return rewriteValueARM64_OpConst32F(v) + return rewriteValueARM64_OpConst32F_0(v) case OpConst64: - return rewriteValueARM64_OpConst64(v) + return rewriteValueARM64_OpConst64_0(v) case OpConst64F: - return rewriteValueARM64_OpConst64F(v) + return rewriteValueARM64_OpConst64F_0(v) case OpConst8: - return rewriteValueARM64_OpConst8(v) + return rewriteValueARM64_OpConst8_0(v) case OpConstBool: - return rewriteValueARM64_OpConstBool(v) + return rewriteValueARM64_OpConstBool_0(v) case OpConstNil: - return rewriteValueARM64_OpConstNil(v) + return rewriteValueARM64_OpConstNil_0(v) case OpConvert: - return rewriteValueARM64_OpConvert(v) + return rewriteValueARM64_OpConvert_0(v) case OpCtz32: - return rewriteValueARM64_OpCtz32(v) + return rewriteValueARM64_OpCtz32_0(v) case OpCtz64: - return rewriteValueARM64_OpCtz64(v) + return rewriteValueARM64_OpCtz64_0(v) case OpCvt32Fto32: - return rewriteValueARM64_OpCvt32Fto32(v) + return rewriteValueARM64_OpCvt32Fto32_0(v) case OpCvt32Fto32U: - return rewriteValueARM64_OpCvt32Fto32U(v) + return rewriteValueARM64_OpCvt32Fto32U_0(v) case OpCvt32Fto64: - return rewriteValueARM64_OpCvt32Fto64(v) + return rewriteValueARM64_OpCvt32Fto64_0(v) case OpCvt32Fto64F: - return rewriteValueARM64_OpCvt32Fto64F(v) + return rewriteValueARM64_OpCvt32Fto64F_0(v) case OpCvt32Fto64U: - return rewriteValueARM64_OpCvt32Fto64U(v) + return rewriteValueARM64_OpCvt32Fto64U_0(v) case OpCvt32Uto32F: - return rewriteValueARM64_OpCvt32Uto32F(v) + return rewriteValueARM64_OpCvt32Uto32F_0(v) case OpCvt32Uto64F: - return rewriteValueARM64_OpCvt32Uto64F(v) + return rewriteValueARM64_OpCvt32Uto64F_0(v) case OpCvt32to32F: - return rewriteValueARM64_OpCvt32to32F(v) + return rewriteValueARM64_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueARM64_OpCvt32to64F(v) + return rewriteValueARM64_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueARM64_OpCvt64Fto32(v) + return rewriteValueARM64_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueARM64_OpCvt64Fto32F(v) + return rewriteValueARM64_OpCvt64Fto32F_0(v) case OpCvt64Fto32U: - return rewriteValueARM64_OpCvt64Fto32U(v) + return rewriteValueARM64_OpCvt64Fto32U_0(v) case OpCvt64Fto64: - return rewriteValueARM64_OpCvt64Fto64(v) + return rewriteValueARM64_OpCvt64Fto64_0(v) case OpCvt64Fto64U: - return rewriteValueARM64_OpCvt64Fto64U(v) + return rewriteValueARM64_OpCvt64Fto64U_0(v) case OpCvt64Uto32F: - return rewriteValueARM64_OpCvt64Uto32F(v) + return rewriteValueARM64_OpCvt64Uto32F_0(v) case OpCvt64Uto64F: - return rewriteValueARM64_OpCvt64Uto64F(v) + return rewriteValueARM64_OpCvt64Uto64F_0(v) case OpCvt64to32F: - return rewriteValueARM64_OpCvt64to32F(v) + return rewriteValueARM64_OpCvt64to32F_0(v) case OpCvt64to64F: - return rewriteValueARM64_OpCvt64to64F(v) + return rewriteValueARM64_OpCvt64to64F_0(v) case OpDiv16: - return rewriteValueARM64_OpDiv16(v) + return rewriteValueARM64_OpDiv16_0(v) case OpDiv16u: - return rewriteValueARM64_OpDiv16u(v) + return rewriteValueARM64_OpDiv16u_0(v) case OpDiv32: - return rewriteValueARM64_OpDiv32(v) + return rewriteValueARM64_OpDiv32_0(v) case OpDiv32F: - return rewriteValueARM64_OpDiv32F(v) + return rewriteValueARM64_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueARM64_OpDiv32u(v) + return rewriteValueARM64_OpDiv32u_0(v) case OpDiv64: - return rewriteValueARM64_OpDiv64(v) + return rewriteValueARM64_OpDiv64_0(v) case OpDiv64F: - return rewriteValueARM64_OpDiv64F(v) + return rewriteValueARM64_OpDiv64F_0(v) case OpDiv64u: - return rewriteValueARM64_OpDiv64u(v) + return rewriteValueARM64_OpDiv64u_0(v) case OpDiv8: - return rewriteValueARM64_OpDiv8(v) + return rewriteValueARM64_OpDiv8_0(v) case OpDiv8u: - return rewriteValueARM64_OpDiv8u(v) + return rewriteValueARM64_OpDiv8u_0(v) case OpEq16: - return rewriteValueARM64_OpEq16(v) + return rewriteValueARM64_OpEq16_0(v) case OpEq32: - return rewriteValueARM64_OpEq32(v) + return rewriteValueARM64_OpEq32_0(v) case OpEq32F: - return rewriteValueARM64_OpEq32F(v) + return rewriteValueARM64_OpEq32F_0(v) case OpEq64: - return rewriteValueARM64_OpEq64(v) + return rewriteValueARM64_OpEq64_0(v) case OpEq64F: - return rewriteValueARM64_OpEq64F(v) + return rewriteValueARM64_OpEq64F_0(v) case OpEq8: - return rewriteValueARM64_OpEq8(v) + return rewriteValueARM64_OpEq8_0(v) case OpEqB: - return rewriteValueARM64_OpEqB(v) + return rewriteValueARM64_OpEqB_0(v) case OpEqPtr: - return rewriteValueARM64_OpEqPtr(v) + return rewriteValueARM64_OpEqPtr_0(v) case OpGeq16: - return rewriteValueARM64_OpGeq16(v) + return rewriteValueARM64_OpGeq16_0(v) case OpGeq16U: - return rewriteValueARM64_OpGeq16U(v) + return rewriteValueARM64_OpGeq16U_0(v) case OpGeq32: - return rewriteValueARM64_OpGeq32(v) + return rewriteValueARM64_OpGeq32_0(v) case OpGeq32F: - return rewriteValueARM64_OpGeq32F(v) + return rewriteValueARM64_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueARM64_OpGeq32U(v) + return rewriteValueARM64_OpGeq32U_0(v) case OpGeq64: - return rewriteValueARM64_OpGeq64(v) + return rewriteValueARM64_OpGeq64_0(v) case OpGeq64F: - return rewriteValueARM64_OpGeq64F(v) + return rewriteValueARM64_OpGeq64F_0(v) case OpGeq64U: - return rewriteValueARM64_OpGeq64U(v) + return rewriteValueARM64_OpGeq64U_0(v) case OpGeq8: - return rewriteValueARM64_OpGeq8(v) + return rewriteValueARM64_OpGeq8_0(v) case OpGeq8U: - return rewriteValueARM64_OpGeq8U(v) + return rewriteValueARM64_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueARM64_OpGetClosurePtr(v) + return rewriteValueARM64_OpGetClosurePtr_0(v) case OpGreater16: - return rewriteValueARM64_OpGreater16(v) + return rewriteValueARM64_OpGreater16_0(v) case OpGreater16U: - return rewriteValueARM64_OpGreater16U(v) + return rewriteValueARM64_OpGreater16U_0(v) case OpGreater32: - return rewriteValueARM64_OpGreater32(v) + return rewriteValueARM64_OpGreater32_0(v) case OpGreater32F: - return rewriteValueARM64_OpGreater32F(v) + return rewriteValueARM64_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueARM64_OpGreater32U(v) + return rewriteValueARM64_OpGreater32U_0(v) case OpGreater64: - return rewriteValueARM64_OpGreater64(v) + return rewriteValueARM64_OpGreater64_0(v) case OpGreater64F: - return rewriteValueARM64_OpGreater64F(v) + return rewriteValueARM64_OpGreater64F_0(v) case OpGreater64U: - return rewriteValueARM64_OpGreater64U(v) + return rewriteValueARM64_OpGreater64U_0(v) case OpGreater8: - return rewriteValueARM64_OpGreater8(v) + return rewriteValueARM64_OpGreater8_0(v) case OpGreater8U: - return rewriteValueARM64_OpGreater8U(v) + return rewriteValueARM64_OpGreater8U_0(v) case OpHmul32: - return rewriteValueARM64_OpHmul32(v) + return rewriteValueARM64_OpHmul32_0(v) case OpHmul32u: - return rewriteValueARM64_OpHmul32u(v) + return rewriteValueARM64_OpHmul32u_0(v) case OpHmul64: - return rewriteValueARM64_OpHmul64(v) + return rewriteValueARM64_OpHmul64_0(v) case OpHmul64u: - return rewriteValueARM64_OpHmul64u(v) + return rewriteValueARM64_OpHmul64u_0(v) case OpInterCall: - return rewriteValueARM64_OpInterCall(v) + return rewriteValueARM64_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueARM64_OpIsInBounds(v) + return rewriteValueARM64_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueARM64_OpIsNonNil(v) + return rewriteValueARM64_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueARM64_OpIsSliceInBounds(v) + return rewriteValueARM64_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueARM64_OpLeq16(v) + return rewriteValueARM64_OpLeq16_0(v) case OpLeq16U: - return rewriteValueARM64_OpLeq16U(v) + return rewriteValueARM64_OpLeq16U_0(v) case OpLeq32: - return rewriteValueARM64_OpLeq32(v) + return rewriteValueARM64_OpLeq32_0(v) case OpLeq32F: - return rewriteValueARM64_OpLeq32F(v) + return rewriteValueARM64_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueARM64_OpLeq32U(v) + return rewriteValueARM64_OpLeq32U_0(v) case OpLeq64: - return rewriteValueARM64_OpLeq64(v) + return rewriteValueARM64_OpLeq64_0(v) case OpLeq64F: - return rewriteValueARM64_OpLeq64F(v) + return rewriteValueARM64_OpLeq64F_0(v) case OpLeq64U: - return rewriteValueARM64_OpLeq64U(v) + return rewriteValueARM64_OpLeq64U_0(v) case OpLeq8: - return rewriteValueARM64_OpLeq8(v) + return rewriteValueARM64_OpLeq8_0(v) case OpLeq8U: - return rewriteValueARM64_OpLeq8U(v) + return rewriteValueARM64_OpLeq8U_0(v) case OpLess16: - return rewriteValueARM64_OpLess16(v) + return rewriteValueARM64_OpLess16_0(v) case OpLess16U: - return rewriteValueARM64_OpLess16U(v) + return rewriteValueARM64_OpLess16U_0(v) case OpLess32: - return rewriteValueARM64_OpLess32(v) + return rewriteValueARM64_OpLess32_0(v) case OpLess32F: - return rewriteValueARM64_OpLess32F(v) + return rewriteValueARM64_OpLess32F_0(v) case OpLess32U: - return rewriteValueARM64_OpLess32U(v) + return rewriteValueARM64_OpLess32U_0(v) case OpLess64: - return rewriteValueARM64_OpLess64(v) + return rewriteValueARM64_OpLess64_0(v) case OpLess64F: - return rewriteValueARM64_OpLess64F(v) + return rewriteValueARM64_OpLess64F_0(v) case OpLess64U: - return rewriteValueARM64_OpLess64U(v) + return rewriteValueARM64_OpLess64U_0(v) case OpLess8: - return rewriteValueARM64_OpLess8(v) + return rewriteValueARM64_OpLess8_0(v) case OpLess8U: - return rewriteValueARM64_OpLess8U(v) + return rewriteValueARM64_OpLess8U_0(v) case OpLoad: - return rewriteValueARM64_OpLoad(v) + return rewriteValueARM64_OpLoad_0(v) case OpLsh16x16: - return rewriteValueARM64_OpLsh16x16(v) + return rewriteValueARM64_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueARM64_OpLsh16x32(v) + return rewriteValueARM64_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueARM64_OpLsh16x64(v) + return rewriteValueARM64_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueARM64_OpLsh16x8(v) + return rewriteValueARM64_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueARM64_OpLsh32x16(v) + return rewriteValueARM64_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueARM64_OpLsh32x32(v) + return rewriteValueARM64_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueARM64_OpLsh32x64(v) + return rewriteValueARM64_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueARM64_OpLsh32x8(v) + return rewriteValueARM64_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValueARM64_OpLsh64x16(v) + return rewriteValueARM64_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValueARM64_OpLsh64x32(v) + return rewriteValueARM64_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValueARM64_OpLsh64x64(v) + return rewriteValueARM64_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValueARM64_OpLsh64x8(v) + return rewriteValueARM64_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValueARM64_OpLsh8x16(v) + return rewriteValueARM64_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueARM64_OpLsh8x32(v) + return rewriteValueARM64_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueARM64_OpLsh8x64(v) + return rewriteValueARM64_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueARM64_OpLsh8x8(v) + return rewriteValueARM64_OpLsh8x8_0(v) case OpMod16: - return rewriteValueARM64_OpMod16(v) + return rewriteValueARM64_OpMod16_0(v) case OpMod16u: - return rewriteValueARM64_OpMod16u(v) + return rewriteValueARM64_OpMod16u_0(v) case OpMod32: - return rewriteValueARM64_OpMod32(v) + return rewriteValueARM64_OpMod32_0(v) case OpMod32u: - return rewriteValueARM64_OpMod32u(v) + return rewriteValueARM64_OpMod32u_0(v) case OpMod64: - return rewriteValueARM64_OpMod64(v) + return rewriteValueARM64_OpMod64_0(v) case OpMod64u: - return rewriteValueARM64_OpMod64u(v) + return rewriteValueARM64_OpMod64u_0(v) case OpMod8: - return rewriteValueARM64_OpMod8(v) + return rewriteValueARM64_OpMod8_0(v) case OpMod8u: - return rewriteValueARM64_OpMod8u(v) + return rewriteValueARM64_OpMod8u_0(v) case OpMove: - return rewriteValueARM64_OpMove(v) + return rewriteValueARM64_OpMove_0(v) || rewriteValueARM64_OpMove_10(v) case OpMul16: - return rewriteValueARM64_OpMul16(v) + return rewriteValueARM64_OpMul16_0(v) case OpMul32: - return rewriteValueARM64_OpMul32(v) + return rewriteValueARM64_OpMul32_0(v) case OpMul32F: - return rewriteValueARM64_OpMul32F(v) + return rewriteValueARM64_OpMul32F_0(v) case OpMul64: - return rewriteValueARM64_OpMul64(v) + return rewriteValueARM64_OpMul64_0(v) case OpMul64F: - return rewriteValueARM64_OpMul64F(v) + return rewriteValueARM64_OpMul64F_0(v) case OpMul8: - return rewriteValueARM64_OpMul8(v) + return rewriteValueARM64_OpMul8_0(v) case OpNeg16: - return rewriteValueARM64_OpNeg16(v) + return rewriteValueARM64_OpNeg16_0(v) case OpNeg32: - return rewriteValueARM64_OpNeg32(v) + return rewriteValueARM64_OpNeg32_0(v) case OpNeg32F: - return rewriteValueARM64_OpNeg32F(v) + return rewriteValueARM64_OpNeg32F_0(v) case OpNeg64: - return rewriteValueARM64_OpNeg64(v) + return rewriteValueARM64_OpNeg64_0(v) case OpNeg64F: - return rewriteValueARM64_OpNeg64F(v) + return rewriteValueARM64_OpNeg64F_0(v) case OpNeg8: - return rewriteValueARM64_OpNeg8(v) + return rewriteValueARM64_OpNeg8_0(v) case OpNeq16: - return rewriteValueARM64_OpNeq16(v) + return rewriteValueARM64_OpNeq16_0(v) case OpNeq32: - return rewriteValueARM64_OpNeq32(v) + return rewriteValueARM64_OpNeq32_0(v) case OpNeq32F: - return rewriteValueARM64_OpNeq32F(v) + return rewriteValueARM64_OpNeq32F_0(v) case OpNeq64: - return rewriteValueARM64_OpNeq64(v) + return rewriteValueARM64_OpNeq64_0(v) case OpNeq64F: - return rewriteValueARM64_OpNeq64F(v) + return rewriteValueARM64_OpNeq64F_0(v) case OpNeq8: - return rewriteValueARM64_OpNeq8(v) + return rewriteValueARM64_OpNeq8_0(v) case OpNeqB: - return rewriteValueARM64_OpNeqB(v) + return rewriteValueARM64_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueARM64_OpNeqPtr(v) + return rewriteValueARM64_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueARM64_OpNilCheck(v) + return rewriteValueARM64_OpNilCheck_0(v) case OpNot: - return rewriteValueARM64_OpNot(v) + return rewriteValueARM64_OpNot_0(v) case OpOffPtr: - return rewriteValueARM64_OpOffPtr(v) + return rewriteValueARM64_OpOffPtr_0(v) case OpOr16: - return rewriteValueARM64_OpOr16(v) + return rewriteValueARM64_OpOr16_0(v) case OpOr32: - return rewriteValueARM64_OpOr32(v) + return rewriteValueARM64_OpOr32_0(v) case OpOr64: - return rewriteValueARM64_OpOr64(v) + return rewriteValueARM64_OpOr64_0(v) case OpOr8: - return rewriteValueARM64_OpOr8(v) + return rewriteValueARM64_OpOr8_0(v) case OpOrB: - return rewriteValueARM64_OpOrB(v) + return rewriteValueARM64_OpOrB_0(v) case OpRound32F: - return rewriteValueARM64_OpRound32F(v) + return rewriteValueARM64_OpRound32F_0(v) case OpRound64F: - return rewriteValueARM64_OpRound64F(v) + return rewriteValueARM64_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueARM64_OpRsh16Ux16(v) + return rewriteValueARM64_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueARM64_OpRsh16Ux32(v) + return rewriteValueARM64_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueARM64_OpRsh16Ux64(v) + return rewriteValueARM64_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueARM64_OpRsh16Ux8(v) + return rewriteValueARM64_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueARM64_OpRsh16x16(v) + return rewriteValueARM64_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueARM64_OpRsh16x32(v) + return rewriteValueARM64_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueARM64_OpRsh16x64(v) + return rewriteValueARM64_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueARM64_OpRsh16x8(v) + return rewriteValueARM64_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueARM64_OpRsh32Ux16(v) + return rewriteValueARM64_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueARM64_OpRsh32Ux32(v) + return rewriteValueARM64_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueARM64_OpRsh32Ux64(v) + return rewriteValueARM64_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueARM64_OpRsh32Ux8(v) + return rewriteValueARM64_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueARM64_OpRsh32x16(v) + return rewriteValueARM64_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueARM64_OpRsh32x32(v) + return rewriteValueARM64_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueARM64_OpRsh32x64(v) + return rewriteValueARM64_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueARM64_OpRsh32x8(v) + return rewriteValueARM64_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValueARM64_OpRsh64Ux16(v) + return rewriteValueARM64_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValueARM64_OpRsh64Ux32(v) + return rewriteValueARM64_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValueARM64_OpRsh64Ux64(v) + return rewriteValueARM64_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValueARM64_OpRsh64Ux8(v) + return rewriteValueARM64_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValueARM64_OpRsh64x16(v) + return rewriteValueARM64_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValueARM64_OpRsh64x32(v) + return rewriteValueARM64_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValueARM64_OpRsh64x64(v) + return rewriteValueARM64_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValueARM64_OpRsh64x8(v) + return rewriteValueARM64_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValueARM64_OpRsh8Ux16(v) + return rewriteValueARM64_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueARM64_OpRsh8Ux32(v) + return rewriteValueARM64_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueARM64_OpRsh8Ux64(v) + return rewriteValueARM64_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueARM64_OpRsh8Ux8(v) + return rewriteValueARM64_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueARM64_OpRsh8x16(v) + return rewriteValueARM64_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueARM64_OpRsh8x32(v) + return rewriteValueARM64_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueARM64_OpRsh8x64(v) + return rewriteValueARM64_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueARM64_OpRsh8x8(v) + return rewriteValueARM64_OpRsh8x8_0(v) case OpSignExt16to32: - return rewriteValueARM64_OpSignExt16to32(v) + return rewriteValueARM64_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValueARM64_OpSignExt16to64(v) + return rewriteValueARM64_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValueARM64_OpSignExt32to64(v) + return rewriteValueARM64_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValueARM64_OpSignExt8to16(v) + return rewriteValueARM64_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueARM64_OpSignExt8to32(v) + return rewriteValueARM64_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValueARM64_OpSignExt8to64(v) + return rewriteValueARM64_OpSignExt8to64_0(v) case OpSlicemask: - return rewriteValueARM64_OpSlicemask(v) + return rewriteValueARM64_OpSlicemask_0(v) case OpSqrt: - return rewriteValueARM64_OpSqrt(v) + return rewriteValueARM64_OpSqrt_0(v) case OpStaticCall: - return rewriteValueARM64_OpStaticCall(v) + return rewriteValueARM64_OpStaticCall_0(v) case OpStore: - return rewriteValueARM64_OpStore(v) + return rewriteValueARM64_OpStore_0(v) case OpSub16: - return rewriteValueARM64_OpSub16(v) + return rewriteValueARM64_OpSub16_0(v) case OpSub32: - return rewriteValueARM64_OpSub32(v) + return rewriteValueARM64_OpSub32_0(v) case OpSub32F: - return rewriteValueARM64_OpSub32F(v) + return rewriteValueARM64_OpSub32F_0(v) case OpSub64: - return rewriteValueARM64_OpSub64(v) + return rewriteValueARM64_OpSub64_0(v) case OpSub64F: - return rewriteValueARM64_OpSub64F(v) + return rewriteValueARM64_OpSub64F_0(v) case OpSub8: - return rewriteValueARM64_OpSub8(v) + return rewriteValueARM64_OpSub8_0(v) case OpSubPtr: - return rewriteValueARM64_OpSubPtr(v) + return rewriteValueARM64_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueARM64_OpTrunc16to8(v) + return rewriteValueARM64_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueARM64_OpTrunc32to16(v) + return rewriteValueARM64_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueARM64_OpTrunc32to8(v) + return rewriteValueARM64_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValueARM64_OpTrunc64to16(v) + return rewriteValueARM64_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValueARM64_OpTrunc64to32(v) + return rewriteValueARM64_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValueARM64_OpTrunc64to8(v) + return rewriteValueARM64_OpTrunc64to8_0(v) case OpXor16: - return rewriteValueARM64_OpXor16(v) + return rewriteValueARM64_OpXor16_0(v) case OpXor32: - return rewriteValueARM64_OpXor32(v) + return rewriteValueARM64_OpXor32_0(v) case OpXor64: - return rewriteValueARM64_OpXor64(v) + return rewriteValueARM64_OpXor64_0(v) case OpXor8: - return rewriteValueARM64_OpXor8(v) + return rewriteValueARM64_OpXor8_0(v) case OpZero: - return rewriteValueARM64_OpZero(v) + return rewriteValueARM64_OpZero_0(v) || rewriteValueARM64_OpZero_10(v) case OpZeroExt16to32: - return rewriteValueARM64_OpZeroExt16to32(v) + return rewriteValueARM64_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValueARM64_OpZeroExt16to64(v) + return rewriteValueARM64_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValueARM64_OpZeroExt32to64(v) + return rewriteValueARM64_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValueARM64_OpZeroExt8to16(v) + return rewriteValueARM64_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueARM64_OpZeroExt8to32(v) + return rewriteValueARM64_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValueARM64_OpZeroExt8to64(v) + return rewriteValueARM64_OpZeroExt8to64_0(v) } return false } -func rewriteValueARM64_OpARM64ADD(v *Value) bool { +func rewriteValueARM64_OpARM64ADD_0(v *Value) bool { // match: (ADD x (MOVDconst [c])) // cond: // result: (ADDconst [c] x) @@ -883,7 +883,7 @@ func rewriteValueARM64_OpARM64ADD(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ADDconst(v *Value) bool { +func rewriteValueARM64_OpARM64ADDconst_0(v *Value) bool { // match: (ADDconst [off1] (MOVDaddr [off2] {sym} ptr)) // cond: // result: (MOVDaddr [off1+off2] {sym} ptr) @@ -963,7 +963,7 @@ func rewriteValueARM64_OpARM64ADDconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool { +func rewriteValueARM64_OpARM64ADDshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftLL (MOVDconst [c]) x [d]) @@ -1053,7 +1053,7 @@ func rewriteValueARM64_OpARM64ADDshiftLL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool { +func rewriteValueARM64_OpARM64ADDshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRA (MOVDconst [c]) x [d]) @@ -1093,7 +1093,7 @@ func rewriteValueARM64_OpARM64ADDshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64ADDshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ADDshiftRL (MOVDconst [c]) x [d]) @@ -1183,7 +1183,7 @@ func rewriteValueARM64_OpARM64ADDshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64AND(v *Value) bool { +func rewriteValueARM64_OpARM64AND_0(v *Value) bool { // match: (AND x (MOVDconst [c])) // cond: // result: (ANDconst [c] x) @@ -1342,6 +1342,9 @@ func rewriteValueARM64_OpARM64AND(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValueARM64_OpARM64AND_10(v *Value) bool { // match: (AND (SRAconst [c] y) x) // cond: // result: (ANDshiftRA x y [c]) @@ -1361,7 +1364,7 @@ func rewriteValueARM64_OpARM64AND(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ANDconst(v *Value) bool { +func rewriteValueARM64_OpARM64ANDconst_0(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVDconst [0]) @@ -1418,7 +1421,7 @@ func rewriteValueARM64_OpARM64ANDconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool { +func rewriteValueARM64_OpARM64ANDshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftLL (MOVDconst [c]) x [d]) @@ -1480,7 +1483,7 @@ func rewriteValueARM64_OpARM64ANDshiftLL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool { +func rewriteValueARM64_OpARM64ANDshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRA (MOVDconst [c]) x [d]) @@ -1542,7 +1545,7 @@ func rewriteValueARM64_OpARM64ANDshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64ANDshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ANDshiftRL (MOVDconst [c]) x [d]) @@ -1604,7 +1607,7 @@ func rewriteValueARM64_OpARM64ANDshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64BIC(v *Value) bool { +func rewriteValueARM64_OpARM64BIC_0(v *Value) bool { // match: (BIC x (MOVDconst [c])) // cond: // result: (BICconst [c] x) @@ -1685,7 +1688,7 @@ func rewriteValueARM64_OpARM64BIC(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64BICconst(v *Value) bool { +func rewriteValueARM64_OpARM64BICconst_0(v *Value) bool { // match: (BICconst [0] x) // cond: // result: x @@ -1726,7 +1729,7 @@ func rewriteValueARM64_OpARM64BICconst(v *Value) bool { } 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))]) @@ -1806,7 +1809,7 @@ func rewriteValueARM64_OpARM64BICshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64BICshiftRL_0(v *Value) bool { // match: (BICshiftRL x (MOVDconst [c]) [d]) // cond: // result: (BICconst x [int64(uint64(c)>>uint64(d))]) @@ -1846,7 +1849,7 @@ func rewriteValueARM64_OpARM64BICshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMP(v *Value) bool { +func rewriteValueARM64_OpARM64CMP_0(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -1991,7 +1994,7 @@ func rewriteValueARM64_OpARM64CMP(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPW(v *Value) bool { +func rewriteValueARM64_OpARM64CMPW_0(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVDconst [c])) @@ -2028,7 +2031,7 @@ func rewriteValueARM64_OpARM64CMPW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool { +func rewriteValueARM64_OpARM64CMPWconst_0(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -2141,7 +2144,7 @@ func rewriteValueARM64_OpARM64CMPWconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPconst(v *Value) bool { +func rewriteValueARM64_OpARM64CMPconst_0(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: x==y // result: (FlagEQ) @@ -2301,7 +2304,7 @@ func rewriteValueARM64_OpARM64CMPconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool { +func rewriteValueARM64_OpARM64CMPshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftLL (MOVDconst [c]) x [d]) @@ -2343,7 +2346,7 @@ func rewriteValueARM64_OpARM64CMPshiftLL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool { +func rewriteValueARM64_OpARM64CMPshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRA (MOVDconst [c]) x [d]) @@ -2385,7 +2388,7 @@ func rewriteValueARM64_OpARM64CMPshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64CMPshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (CMPshiftRL (MOVDconst [c]) x [d]) @@ -2427,7 +2430,7 @@ func rewriteValueARM64_OpARM64CMPshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CSELULT(v *Value) bool { +func rewriteValueARM64_OpARM64CSELULT_0(v *Value) bool { // match: (CSELULT x (MOVDconst [0]) flag) // cond: // result: (CSELULT0 x flag) @@ -2518,7 +2521,7 @@ func rewriteValueARM64_OpARM64CSELULT(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool { +func rewriteValueARM64_OpARM64CSELULT0_0(v *Value) bool { // match: (CSELULT0 _ (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -2585,7 +2588,7 @@ func rewriteValueARM64_OpARM64CSELULT0(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64DIV(v *Value) bool { +func rewriteValueARM64_OpARM64DIV_0(v *Value) bool { // match: (DIV (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(c)/int64(d)]) @@ -2606,7 +2609,7 @@ func rewriteValueARM64_OpARM64DIV(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64DIVW(v *Value) bool { +func rewriteValueARM64_OpARM64DIVW_0(v *Value) bool { // match: (DIVW (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(int32(c)/int32(d))]) @@ -2627,7 +2630,7 @@ func rewriteValueARM64_OpARM64DIVW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64Equal(v *Value) bool { +func rewriteValueARM64_OpARM64Equal_0(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -2703,7 +2706,7 @@ func rewriteValueARM64_OpARM64Equal(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool { +func rewriteValueARM64_OpARM64FMOVDload_0(v *Value) bool { // match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 8, sym) // result: (FMOVDload [off1+off2] {sym} ptr mem) @@ -2753,7 +2756,7 @@ func rewriteValueARM64_OpARM64FMOVDload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool { +func rewriteValueARM64_OpARM64FMOVDstore_0(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 8, sym) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -2807,7 +2810,7 @@ func rewriteValueARM64_OpARM64FMOVDstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool { +func rewriteValueARM64_OpARM64FMOVSload_0(v *Value) bool { // match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (FMOVSload [off1+off2] {sym} ptr mem) @@ -2857,7 +2860,7 @@ func rewriteValueARM64_OpARM64FMOVSload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool { +func rewriteValueARM64_OpARM64FMOVSstore_0(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -2911,7 +2914,7 @@ func rewriteValueARM64_OpARM64FMOVSstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool { +func rewriteValueARM64_OpARM64GreaterEqual_0(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -2987,7 +2990,7 @@ func rewriteValueARM64_OpARM64GreaterEqual(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool { +func rewriteValueARM64_OpARM64GreaterEqualU_0(v *Value) bool { // match: (GreaterEqualU (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3063,7 +3066,7 @@ func rewriteValueARM64_OpARM64GreaterEqualU(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool { +func rewriteValueARM64_OpARM64GreaterThan_0(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3139,7 +3142,7 @@ func rewriteValueARM64_OpARM64GreaterThan(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool { +func rewriteValueARM64_OpARM64GreaterThanU_0(v *Value) bool { // match: (GreaterThanU (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3215,7 +3218,7 @@ func rewriteValueARM64_OpARM64GreaterThanU(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64LessEqual(v *Value) bool { +func rewriteValueARM64_OpARM64LessEqual_0(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3291,7 +3294,7 @@ func rewriteValueARM64_OpARM64LessEqual(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool { +func rewriteValueARM64_OpARM64LessEqualU_0(v *Value) bool { // match: (LessEqualU (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -3367,7 +3370,7 @@ func rewriteValueARM64_OpARM64LessEqualU(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64LessThan(v *Value) bool { +func rewriteValueARM64_OpARM64LessThan_0(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3443,7 +3446,7 @@ func rewriteValueARM64_OpARM64LessThan(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64LessThanU(v *Value) bool { +func rewriteValueARM64_OpARM64LessThanU_0(v *Value) bool { // match: (LessThanU (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -3519,7 +3522,7 @@ func rewriteValueARM64_OpARM64LessThanU(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOD(v *Value) bool { +func rewriteValueARM64_OpARM64MOD_0(v *Value) bool { // match: (MOD (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(c)%int64(d)]) @@ -3540,7 +3543,7 @@ func rewriteValueARM64_OpARM64MOD(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MODW(v *Value) bool { +func rewriteValueARM64_OpARM64MODW_0(v *Value) bool { // match: (MODW (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(int32(c)%int32(d))]) @@ -3561,7 +3564,7 @@ func rewriteValueARM64_OpARM64MODW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBUload_0(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 1, sym) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3632,7 +3635,7 @@ func rewriteValueARM64_OpARM64MOVBUload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBUreg_0(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -3672,7 +3675,7 @@ func rewriteValueARM64_OpARM64MOVBUreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBload_0(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 1, sym) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3743,7 +3746,7 @@ func rewriteValueARM64_OpARM64MOVBload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBreg_0(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -3783,7 +3786,7 @@ func rewriteValueARM64_OpARM64MOVBreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBstore_0(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 1, sym) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -3985,7 +3988,7 @@ func rewriteValueARM64_OpARM64MOVBstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool { +func rewriteValueARM64_OpARM64MOVBstorezero_0(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 1, sym) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -4035,7 +4038,7 @@ func rewriteValueARM64_OpARM64MOVBstorezero(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVDload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVDload_0(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 8, sym) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -4106,7 +4109,7 @@ func rewriteValueARM64_OpARM64MOVDload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVDreg_0(v *Value) bool { // match: (MOVDreg x) // cond: x.Uses == 1 // result: (MOVDnop x) @@ -4134,7 +4137,7 @@ func rewriteValueARM64_OpARM64MOVDreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool { +func rewriteValueARM64_OpARM64MOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 8, sym) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -4210,7 +4213,7 @@ func rewriteValueARM64_OpARM64MOVDstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool { +func rewriteValueARM64_OpARM64MOVDstorezero_0(v *Value) bool { // match: (MOVDstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 8, sym) // result: (MOVDstorezero [off1+off2] {sym} ptr mem) @@ -4260,7 +4263,7 @@ func rewriteValueARM64_OpARM64MOVDstorezero(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHUload_0(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 2, sym) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4331,7 +4334,7 @@ func rewriteValueARM64_OpARM64MOVHUload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHUreg_0(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -4395,7 +4398,7 @@ func rewriteValueARM64_OpARM64MOVHUreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 2, sym) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4466,7 +4469,7 @@ func rewriteValueARM64_OpARM64MOVHload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHreg_0(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -4554,7 +4557,7 @@ func rewriteValueARM64_OpARM64MOVHreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHstore_0(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 2, sym) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4714,7 +4717,7 @@ func rewriteValueARM64_OpARM64MOVHstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool { +func rewriteValueARM64_OpARM64MOVHstorezero_0(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 2, sym) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4764,7 +4767,7 @@ func rewriteValueARM64_OpARM64MOVHstorezero(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWUload_0(v *Value) bool { // match: (MOVWUload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (MOVWUload [off1+off2] {sym} ptr mem) @@ -4835,7 +4838,7 @@ func rewriteValueARM64_OpARM64MOVWUload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWUreg_0(v *Value) bool { // match: (MOVWUreg x:(MOVBUload _ _)) // cond: // result: (MOVDreg x) @@ -4923,7 +4926,7 @@ func rewriteValueARM64_OpARM64MOVWUreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWload(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWload_0(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -4994,7 +4997,7 @@ func rewriteValueARM64_OpARM64MOVWload(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWreg_0(v *Value) bool { // match: (MOVWreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -5115,6 +5118,9 @@ func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueARM64_OpARM64MOVWreg_10(v *Value) bool { // match: (MOVWreg (MOVDconst [c])) // cond: // result: (MOVDconst [int64(int32(c))]) @@ -5130,7 +5136,7 @@ func rewriteValueARM64_OpARM64MOVWreg(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWstore_0(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -5248,7 +5254,7 @@ func rewriteValueARM64_OpARM64MOVWstore(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool { +func rewriteValueARM64_OpARM64MOVWstorezero_0(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDconst [off2] ptr) mem) // cond: fitsARM64Offset(off1+off2, 4, sym) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -5298,9 +5304,7 @@ func rewriteValueARM64_OpARM64MOVWstorezero(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MUL(v *Value) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MUL_0(v *Value) bool { // match: (MUL x (MOVDconst [-1])) // cond: // result: (NEG x) @@ -5471,6 +5475,11 @@ func rewriteValueARM64_OpARM64MUL(v *Value) bool { 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) x [log2(c+1)]) @@ -5693,6 +5702,9 @@ func rewriteValueARM64_OpARM64MUL(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValueARM64_OpARM64MUL_20(v *Value) bool { // match: (MUL (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [c*d]) @@ -5731,9 +5743,7 @@ func rewriteValueARM64_OpARM64MUL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MULW(v *Value) bool { - b := v.Block - _ = b +func rewriteValueARM64_OpARM64MULW_0(v *Value) bool { // match: (MULW x (MOVDconst [c])) // cond: int32(c)==-1 // result: (NEG x) @@ -5910,6 +5920,11 @@ func rewriteValueARM64_OpARM64MULW(v *Value) bool { 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) x [log2(c+1)]) @@ -6132,6 +6147,9 @@ func rewriteValueARM64_OpARM64MULW(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValueARM64_OpARM64MULW_20(v *Value) bool { // match: (MULW (MOVDconst [c]) (MOVDconst [d])) // cond: // result: (MOVDconst [int64(int32(c)*int32(d))]) @@ -6170,7 +6188,7 @@ func rewriteValueARM64_OpARM64MULW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64MVN(v *Value) bool { +func rewriteValueARM64_OpARM64MVN_0(v *Value) bool { // match: (MVN (MOVDconst [c])) // cond: // result: (MOVDconst [^c]) @@ -6186,7 +6204,7 @@ func rewriteValueARM64_OpARM64MVN(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64NEG(v *Value) bool { +func rewriteValueARM64_OpARM64NEG_0(v *Value) bool { // match: (NEG (MOVDconst [c])) // cond: // result: (MOVDconst [-c]) @@ -6202,7 +6220,7 @@ func rewriteValueARM64_OpARM64NEG(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64NotEqual(v *Value) bool { +func rewriteValueARM64_OpARM64NotEqual_0(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -6278,7 +6296,7 @@ func rewriteValueARM64_OpARM64NotEqual(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64OR(v *Value) bool { +func rewriteValueARM64_OpARM64OR_0(v *Value) bool { b := v.Block _ = b // match: (OR x (MOVDconst [c])) @@ -6533,6 +6551,11 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueARM64_OpARM64OR_10(v *Value) bool { + b := v.Block + _ = b // match: (OR 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 {s} (OffPtr [i0] p) mem) @@ -7696,7 +7719,7 @@ func rewriteValueARM64_OpARM64OR(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ORconst(v *Value) bool { +func rewriteValueARM64_OpARM64ORconst_0(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -7753,7 +7776,7 @@ func rewriteValueARM64_OpARM64ORconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool { +func rewriteValueARM64_OpARM64ORshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftLL (MOVDconst [c]) x [d]) @@ -8247,6 +8270,11 @@ func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool { v0.AddArg(v1) return true } + return false +} +func rewriteValueARM64_OpARM64ORshiftLL_10(v *Value) bool { + b := v.Block + _ = b // match: (ORshiftLL [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 (MOVDload {s} (OffPtr [i0] p) mem)) @@ -8379,7 +8407,7 @@ func rewriteValueARM64_OpARM64ORshiftLL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool { +func rewriteValueARM64_OpARM64ORshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRA (MOVDconst [c]) x [d]) @@ -8441,7 +8469,7 @@ func rewriteValueARM64_OpARM64ORshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64ORshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (ORshiftRL (MOVDconst [c]) x [d]) @@ -8553,7 +8581,7 @@ func rewriteValueARM64_OpARM64ORshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SLL(v *Value) bool { +func rewriteValueARM64_OpARM64SLL_0(v *Value) bool { // match: (SLL x (MOVDconst [c])) // cond: // result: (SLLconst x [c&63]) @@ -8571,7 +8599,7 @@ func rewriteValueARM64_OpARM64SLL(v *Value) bool { } 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)]) @@ -8644,7 +8672,7 @@ func rewriteValueARM64_OpARM64SRAconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SRL(v *Value) bool { +func rewriteValueARM64_OpARM64SRL_0(v *Value) bool { // match: (SRL x (MOVDconst [c])) // cond: // result: (SRLconst x [c&63]) @@ -8662,7 +8690,7 @@ func rewriteValueARM64_OpARM64SRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SRLconst(v *Value) bool { +func rewriteValueARM64_OpARM64SRLconst_0(v *Value) bool { // match: (SRLconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [int64(uint64(d)>>uint64(c))]) @@ -8700,7 +8728,7 @@ func rewriteValueARM64_OpARM64SRLconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SUB(v *Value) bool { +func rewriteValueARM64_OpARM64SUB_0(v *Value) bool { b := v.Block _ = b // match: (SUB x (MOVDconst [c])) @@ -8821,7 +8849,7 @@ func rewriteValueARM64_OpARM64SUB(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SUBconst(v *Value) bool { +func rewriteValueARM64_OpARM64SUBconst_0(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -8883,7 +8911,7 @@ func rewriteValueARM64_OpARM64SUBconst(v *Value) bool { } 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))]) @@ -8963,7 +8991,7 @@ func rewriteValueARM64_OpARM64SUBshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64SUBshiftRL_0(v *Value) bool { // match: (SUBshiftRL x (MOVDconst [c]) [d]) // cond: // result: (SUBconst x [int64(uint64(c)>>uint64(d))]) @@ -9003,7 +9031,7 @@ func rewriteValueARM64_OpARM64SUBshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64UDIV(v *Value) bool { +func rewriteValueARM64_OpARM64UDIV_0(v *Value) bool { // match: (UDIV x (MOVDconst [1])) // cond: // result: x @@ -9059,7 +9087,7 @@ func rewriteValueARM64_OpARM64UDIV(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64UDIVW(v *Value) bool { +func rewriteValueARM64_OpARM64UDIVW_0(v *Value) bool { // match: (UDIVW x (MOVDconst [c])) // cond: uint32(c)==1 // result: x @@ -9116,7 +9144,7 @@ func rewriteValueARM64_OpARM64UDIVW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64UMOD(v *Value) bool { +func rewriteValueARM64_OpARM64UMOD_0(v *Value) bool { // match: (UMOD _ (MOVDconst [1])) // cond: // result: (MOVDconst [0]) @@ -9170,7 +9198,7 @@ func rewriteValueARM64_OpARM64UMOD(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64UMODW(v *Value) bool { +func rewriteValueARM64_OpARM64UMODW_0(v *Value) bool { // match: (UMODW _ (MOVDconst [c])) // cond: uint32(c)==1 // result: (MOVDconst [0]) @@ -9225,7 +9253,7 @@ func rewriteValueARM64_OpARM64UMODW(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64XOR(v *Value) bool { +func rewriteValueARM64_OpARM64XOR_0(v *Value) bool { // match: (XOR x (MOVDconst [c])) // cond: // result: (XORconst [c] x) @@ -9372,7 +9400,7 @@ func rewriteValueARM64_OpARM64XOR(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64XORconst(v *Value) bool { +func rewriteValueARM64_OpARM64XORconst_0(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -9430,7 +9458,7 @@ func rewriteValueARM64_OpARM64XORconst(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool { +func rewriteValueARM64_OpARM64XORshiftLL_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftLL (MOVDconst [c]) x [d]) @@ -9541,7 +9569,7 @@ func rewriteValueARM64_OpARM64XORshiftLL(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool { +func rewriteValueARM64_OpARM64XORshiftRA_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRA (MOVDconst [c]) x [d]) @@ -9602,7 +9630,7 @@ func rewriteValueARM64_OpARM64XORshiftRA(v *Value) bool { } return false } -func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool { +func rewriteValueARM64_OpARM64XORshiftRL_0(v *Value) bool { b := v.Block _ = b // match: (XORshiftRL (MOVDconst [c]) x [d]) @@ -9713,7 +9741,7 @@ func rewriteValueARM64_OpARM64XORshiftRL(v *Value) bool { } return false } -func rewriteValueARM64_OpAdd16(v *Value) bool { +func rewriteValueARM64_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -9726,7 +9754,7 @@ func rewriteValueARM64_OpAdd16(v *Value) bool { return true } } -func rewriteValueARM64_OpAdd32(v *Value) bool { +func rewriteValueARM64_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -9739,7 +9767,7 @@ func rewriteValueARM64_OpAdd32(v *Value) bool { return true } } -func rewriteValueARM64_OpAdd32F(v *Value) bool { +func rewriteValueARM64_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -9752,7 +9780,7 @@ func rewriteValueARM64_OpAdd32F(v *Value) bool { return true } } -func rewriteValueARM64_OpAdd64(v *Value) bool { +func rewriteValueARM64_OpAdd64_0(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -9765,7 +9793,7 @@ func rewriteValueARM64_OpAdd64(v *Value) bool { return true } } -func rewriteValueARM64_OpAdd64F(v *Value) bool { +func rewriteValueARM64_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADDD x y) @@ -9778,7 +9806,7 @@ func rewriteValueARM64_OpAdd64F(v *Value) bool { return true } } -func rewriteValueARM64_OpAdd8(v *Value) bool { +func rewriteValueARM64_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -9791,7 +9819,7 @@ func rewriteValueARM64_OpAdd8(v *Value) bool { return true } } -func rewriteValueARM64_OpAddPtr(v *Value) bool { +func rewriteValueARM64_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -9804,7 +9832,7 @@ func rewriteValueARM64_OpAddPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpAddr(v *Value) bool { +func rewriteValueARM64_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -9817,7 +9845,7 @@ func rewriteValueARM64_OpAddr(v *Value) bool { return true } } -func rewriteValueARM64_OpAnd16(v *Value) bool { +func rewriteValueARM64_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -9830,7 +9858,7 @@ func rewriteValueARM64_OpAnd16(v *Value) bool { return true } } -func rewriteValueARM64_OpAnd32(v *Value) bool { +func rewriteValueARM64_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -9843,7 +9871,7 @@ func rewriteValueARM64_OpAnd32(v *Value) bool { return true } } -func rewriteValueARM64_OpAnd64(v *Value) bool { +func rewriteValueARM64_OpAnd64_0(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -9856,7 +9884,7 @@ func rewriteValueARM64_OpAnd64(v *Value) bool { return true } } -func rewriteValueARM64_OpAnd8(v *Value) bool { +func rewriteValueARM64_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -9869,7 +9897,7 @@ func rewriteValueARM64_OpAnd8(v *Value) bool { return true } } -func rewriteValueARM64_OpAndB(v *Value) bool { +func rewriteValueARM64_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -9882,7 +9910,7 @@ func rewriteValueARM64_OpAndB(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicAdd32(v *Value) bool { +func rewriteValueARM64_OpAtomicAdd32_0(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd32 ptr val mem) @@ -9897,7 +9925,7 @@ func rewriteValueARM64_OpAtomicAdd32(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicAdd64(v *Value) bool { +func rewriteValueARM64_OpAtomicAdd64_0(v *Value) bool { // match: (AtomicAdd64 ptr val mem) // cond: // result: (LoweredAtomicAdd64 ptr val mem) @@ -9912,7 +9940,7 @@ func rewriteValueARM64_OpAtomicAdd64(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicAnd8(v *Value) bool { +func rewriteValueARM64_OpAtomicAnd8_0(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (LoweredAtomicAnd8 ptr val mem) @@ -9927,7 +9955,7 @@ func rewriteValueARM64_OpAtomicAnd8(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool { +func rewriteValueARM64_OpAtomicCompareAndSwap32_0(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -9944,7 +9972,7 @@ func rewriteValueARM64_OpAtomicCompareAndSwap32(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool { +func rewriteValueARM64_OpAtomicCompareAndSwap64_0(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -9961,7 +9989,7 @@ func rewriteValueARM64_OpAtomicCompareAndSwap64(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicExchange32(v *Value) bool { +func rewriteValueARM64_OpAtomicExchange32_0(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -9976,7 +10004,7 @@ func rewriteValueARM64_OpAtomicExchange32(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicExchange64(v *Value) bool { +func rewriteValueARM64_OpAtomicExchange64_0(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -9991,7 +10019,7 @@ func rewriteValueARM64_OpAtomicExchange64(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicLoad32(v *Value) bool { +func rewriteValueARM64_OpAtomicLoad32_0(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LDARW ptr mem) @@ -10004,7 +10032,7 @@ func rewriteValueARM64_OpAtomicLoad32(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicLoad64(v *Value) bool { +func rewriteValueARM64_OpAtomicLoad64_0(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (LDAR ptr mem) @@ -10017,7 +10045,7 @@ func rewriteValueARM64_OpAtomicLoad64(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool { +func rewriteValueARM64_OpAtomicLoadPtr_0(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LDAR ptr mem) @@ -10030,7 +10058,7 @@ func rewriteValueARM64_OpAtomicLoadPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicOr8(v *Value) bool { +func rewriteValueARM64_OpAtomicOr8_0(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (LoweredAtomicOr8 ptr val mem) @@ -10045,7 +10073,7 @@ func rewriteValueARM64_OpAtomicOr8(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicStore32(v *Value) bool { +func rewriteValueARM64_OpAtomicStore32_0(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (STLRW ptr val mem) @@ -10060,7 +10088,7 @@ func rewriteValueARM64_OpAtomicStore32(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicStore64(v *Value) bool { +func rewriteValueARM64_OpAtomicStore64_0(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (STLR ptr val mem) @@ -10075,7 +10103,7 @@ func rewriteValueARM64_OpAtomicStore64(v *Value) bool { return true } } -func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool { +func rewriteValueARM64_OpAtomicStorePtrNoWB_0(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (STLR ptr val mem) @@ -10090,7 +10118,7 @@ func rewriteValueARM64_OpAtomicStorePtrNoWB(v *Value) bool { return true } } -func rewriteValueARM64_OpAvg64u(v *Value) bool { +func rewriteValueARM64_OpAvg64u_0(v *Value) bool { b := v.Block _ = b // match: (Avg64u x y) @@ -10112,7 +10140,7 @@ func rewriteValueARM64_OpAvg64u(v *Value) bool { return true } } -func rewriteValueARM64_OpBitLen64(v *Value) bool { +func rewriteValueARM64_OpBitLen64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10132,7 +10160,7 @@ func rewriteValueARM64_OpBitLen64(v *Value) bool { return true } } -func rewriteValueARM64_OpBitRev16(v *Value) bool { +func rewriteValueARM64_OpBitRev16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10150,7 +10178,7 @@ func rewriteValueARM64_OpBitRev16(v *Value) bool { return true } } -func rewriteValueARM64_OpBitRev32(v *Value) bool { +func rewriteValueARM64_OpBitRev32_0(v *Value) bool { // match: (BitRev32 x) // cond: // result: (RBITW x) @@ -10161,7 +10189,7 @@ func rewriteValueARM64_OpBitRev32(v *Value) bool { return true } } -func rewriteValueARM64_OpBitRev64(v *Value) bool { +func rewriteValueARM64_OpBitRev64_0(v *Value) bool { // match: (BitRev64 x) // cond: // result: (RBIT x) @@ -10172,7 +10200,7 @@ func rewriteValueARM64_OpBitRev64(v *Value) bool { return true } } -func rewriteValueARM64_OpBitRev8(v *Value) bool { +func rewriteValueARM64_OpBitRev8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10190,7 +10218,7 @@ func rewriteValueARM64_OpBitRev8(v *Value) bool { return true } } -func rewriteValueARM64_OpBswap32(v *Value) bool { +func rewriteValueARM64_OpBswap32_0(v *Value) bool { // match: (Bswap32 x) // cond: // result: (REVW x) @@ -10201,7 +10229,7 @@ func rewriteValueARM64_OpBswap32(v *Value) bool { return true } } -func rewriteValueARM64_OpBswap64(v *Value) bool { +func rewriteValueARM64_OpBswap64_0(v *Value) bool { // match: (Bswap64 x) // cond: // result: (REV x) @@ -10212,7 +10240,7 @@ func rewriteValueARM64_OpBswap64(v *Value) bool { return true } } -func rewriteValueARM64_OpClosureCall(v *Value) bool { +func rewriteValueARM64_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -10229,7 +10257,7 @@ func rewriteValueARM64_OpClosureCall(v *Value) bool { return true } } -func rewriteValueARM64_OpCom16(v *Value) bool { +func rewriteValueARM64_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (MVN x) @@ -10240,7 +10268,7 @@ func rewriteValueARM64_OpCom16(v *Value) bool { return true } } -func rewriteValueARM64_OpCom32(v *Value) bool { +func rewriteValueARM64_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (MVN x) @@ -10251,7 +10279,7 @@ func rewriteValueARM64_OpCom32(v *Value) bool { return true } } -func rewriteValueARM64_OpCom64(v *Value) bool { +func rewriteValueARM64_OpCom64_0(v *Value) bool { // match: (Com64 x) // cond: // result: (MVN x) @@ -10262,7 +10290,7 @@ func rewriteValueARM64_OpCom64(v *Value) bool { return true } } -func rewriteValueARM64_OpCom8(v *Value) bool { +func rewriteValueARM64_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (MVN x) @@ -10273,7 +10301,7 @@ func rewriteValueARM64_OpCom8(v *Value) bool { return true } } -func rewriteValueARM64_OpConst16(v *Value) bool { +func rewriteValueARM64_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -10284,7 +10312,7 @@ func rewriteValueARM64_OpConst16(v *Value) bool { return true } } -func rewriteValueARM64_OpConst32(v *Value) bool { +func rewriteValueARM64_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -10295,7 +10323,7 @@ func rewriteValueARM64_OpConst32(v *Value) bool { return true } } -func rewriteValueARM64_OpConst32F(v *Value) bool { +func rewriteValueARM64_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -10306,7 +10334,7 @@ func rewriteValueARM64_OpConst32F(v *Value) bool { return true } } -func rewriteValueARM64_OpConst64(v *Value) bool { +func rewriteValueARM64_OpConst64_0(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -10317,7 +10345,7 @@ func rewriteValueARM64_OpConst64(v *Value) bool { return true } } -func rewriteValueARM64_OpConst64F(v *Value) bool { +func rewriteValueARM64_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -10328,7 +10356,7 @@ func rewriteValueARM64_OpConst64F(v *Value) bool { return true } } -func rewriteValueARM64_OpConst8(v *Value) bool { +func rewriteValueARM64_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -10339,7 +10367,7 @@ func rewriteValueARM64_OpConst8(v *Value) bool { return true } } -func rewriteValueARM64_OpConstBool(v *Value) bool { +func rewriteValueARM64_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -10350,7 +10378,7 @@ func rewriteValueARM64_OpConstBool(v *Value) bool { return true } } -func rewriteValueARM64_OpConstNil(v *Value) bool { +func rewriteValueARM64_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -10360,7 +10388,7 @@ func rewriteValueARM64_OpConstNil(v *Value) bool { return true } } -func rewriteValueARM64_OpConvert(v *Value) bool { +func rewriteValueARM64_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVDconvert x mem) @@ -10373,7 +10401,7 @@ func rewriteValueARM64_OpConvert(v *Value) bool { return true } } -func rewriteValueARM64_OpCtz32(v *Value) bool { +func rewriteValueARM64_OpCtz32_0(v *Value) bool { b := v.Block _ = b // match: (Ctz32 x) @@ -10389,7 +10417,7 @@ func rewriteValueARM64_OpCtz32(v *Value) bool { return true } } -func rewriteValueARM64_OpCtz64(v *Value) bool { +func rewriteValueARM64_OpCtz64_0(v *Value) bool { b := v.Block _ = b // match: (Ctz64 x) @@ -10405,7 +10433,7 @@ func rewriteValueARM64_OpCtz64(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Fto32(v *Value) bool { +func rewriteValueARM64_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (FCVTZSSW x) @@ -10416,7 +10444,7 @@ func rewriteValueARM64_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool { +func rewriteValueARM64_OpCvt32Fto32U_0(v *Value) bool { // match: (Cvt32Fto32U x) // cond: // result: (FCVTZUSW x) @@ -10427,7 +10455,7 @@ func rewriteValueARM64_OpCvt32Fto32U(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64(v *Value) bool { +func rewriteValueARM64_OpCvt32Fto64_0(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (FCVTZSS x) @@ -10438,7 +10466,7 @@ func rewriteValueARM64_OpCvt32Fto64(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool { +func rewriteValueARM64_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (FCVTSD x) @@ -10449,7 +10477,7 @@ func rewriteValueARM64_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool { +func rewriteValueARM64_OpCvt32Fto64U_0(v *Value) bool { // match: (Cvt32Fto64U x) // cond: // result: (FCVTZUS x) @@ -10460,7 +10488,7 @@ func rewriteValueARM64_OpCvt32Fto64U(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool { +func rewriteValueARM64_OpCvt32Uto32F_0(v *Value) bool { // match: (Cvt32Uto32F x) // cond: // result: (UCVTFWS x) @@ -10471,7 +10499,7 @@ func rewriteValueARM64_OpCvt32Uto32F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool { +func rewriteValueARM64_OpCvt32Uto64F_0(v *Value) bool { // match: (Cvt32Uto64F x) // cond: // result: (UCVTFWD x) @@ -10482,7 +10510,7 @@ func rewriteValueARM64_OpCvt32Uto64F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32to32F(v *Value) bool { +func rewriteValueARM64_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (SCVTFWS x) @@ -10493,7 +10521,7 @@ func rewriteValueARM64_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt32to64F(v *Value) bool { +func rewriteValueARM64_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (SCVTFWD x) @@ -10504,7 +10532,7 @@ func rewriteValueARM64_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32(v *Value) bool { +func rewriteValueARM64_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (FCVTZSDW x) @@ -10515,7 +10543,7 @@ func rewriteValueARM64_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool { +func rewriteValueARM64_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (FCVTDS x) @@ -10526,7 +10554,7 @@ func rewriteValueARM64_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool { +func rewriteValueARM64_OpCvt64Fto32U_0(v *Value) bool { // match: (Cvt64Fto32U x) // cond: // result: (FCVTZUDW x) @@ -10537,7 +10565,7 @@ func rewriteValueARM64_OpCvt64Fto32U(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Fto64(v *Value) bool { +func rewriteValueARM64_OpCvt64Fto64_0(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (FCVTZSD x) @@ -10548,7 +10576,7 @@ func rewriteValueARM64_OpCvt64Fto64(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool { +func rewriteValueARM64_OpCvt64Fto64U_0(v *Value) bool { // match: (Cvt64Fto64U x) // cond: // result: (FCVTZUD x) @@ -10559,7 +10587,7 @@ func rewriteValueARM64_OpCvt64Fto64U(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool { +func rewriteValueARM64_OpCvt64Uto32F_0(v *Value) bool { // match: (Cvt64Uto32F x) // cond: // result: (UCVTFS x) @@ -10570,7 +10598,7 @@ func rewriteValueARM64_OpCvt64Uto32F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool { +func rewriteValueARM64_OpCvt64Uto64F_0(v *Value) bool { // match: (Cvt64Uto64F x) // cond: // result: (UCVTFD x) @@ -10581,7 +10609,7 @@ func rewriteValueARM64_OpCvt64Uto64F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64to32F(v *Value) bool { +func rewriteValueARM64_OpCvt64to32F_0(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (SCVTFS x) @@ -10592,7 +10620,7 @@ func rewriteValueARM64_OpCvt64to32F(v *Value) bool { return true } } -func rewriteValueARM64_OpCvt64to64F(v *Value) bool { +func rewriteValueARM64_OpCvt64to64F_0(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (SCVTFD x) @@ -10603,7 +10631,7 @@ func rewriteValueARM64_OpCvt64to64F(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv16(v *Value) bool { +func rewriteValueARM64_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10624,7 +10652,7 @@ func rewriteValueARM64_OpDiv16(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv16u(v *Value) bool { +func rewriteValueARM64_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10645,7 +10673,7 @@ func rewriteValueARM64_OpDiv16u(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv32(v *Value) bool { +func rewriteValueARM64_OpDiv32_0(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVW x y) @@ -10658,7 +10686,7 @@ func rewriteValueARM64_OpDiv32(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv32F(v *Value) bool { +func rewriteValueARM64_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -10671,7 +10699,7 @@ func rewriteValueARM64_OpDiv32F(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv32u(v *Value) bool { +func rewriteValueARM64_OpDiv32u_0(v *Value) bool { // match: (Div32u x y) // cond: // result: (UDIVW x y) @@ -10684,7 +10712,7 @@ func rewriteValueARM64_OpDiv32u(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv64(v *Value) bool { +func rewriteValueARM64_OpDiv64_0(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIV x y) @@ -10697,7 +10725,7 @@ func rewriteValueARM64_OpDiv64(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv64F(v *Value) bool { +func rewriteValueARM64_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIVD x y) @@ -10710,7 +10738,7 @@ func rewriteValueARM64_OpDiv64F(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv64u(v *Value) bool { +func rewriteValueARM64_OpDiv64u_0(v *Value) bool { // match: (Div64u x y) // cond: // result: (UDIV x y) @@ -10723,7 +10751,7 @@ func rewriteValueARM64_OpDiv64u(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv8(v *Value) bool { +func rewriteValueARM64_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10744,7 +10772,7 @@ func rewriteValueARM64_OpDiv8(v *Value) bool { return true } } -func rewriteValueARM64_OpDiv8u(v *Value) bool { +func rewriteValueARM64_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10765,7 +10793,7 @@ func rewriteValueARM64_OpDiv8u(v *Value) bool { return true } } -func rewriteValueARM64_OpEq16(v *Value) bool { +func rewriteValueARM64_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10788,7 +10816,7 @@ func rewriteValueARM64_OpEq16(v *Value) bool { return true } } -func rewriteValueARM64_OpEq32(v *Value) bool { +func rewriteValueARM64_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -10805,7 +10833,7 @@ func rewriteValueARM64_OpEq32(v *Value) bool { return true } } -func rewriteValueARM64_OpEq32F(v *Value) bool { +func rewriteValueARM64_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -10822,7 +10850,7 @@ func rewriteValueARM64_OpEq32F(v *Value) bool { return true } } -func rewriteValueARM64_OpEq64(v *Value) bool { +func rewriteValueARM64_OpEq64_0(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -10839,7 +10867,7 @@ func rewriteValueARM64_OpEq64(v *Value) bool { return true } } -func rewriteValueARM64_OpEq64F(v *Value) bool { +func rewriteValueARM64_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -10856,7 +10884,7 @@ func rewriteValueARM64_OpEq64F(v *Value) bool { return true } } -func rewriteValueARM64_OpEq8(v *Value) bool { +func rewriteValueARM64_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10879,7 +10907,7 @@ func rewriteValueARM64_OpEq8(v *Value) bool { return true } } -func rewriteValueARM64_OpEqB(v *Value) bool { +func rewriteValueARM64_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10901,7 +10929,7 @@ func rewriteValueARM64_OpEqB(v *Value) bool { return true } } -func rewriteValueARM64_OpEqPtr(v *Value) bool { +func rewriteValueARM64_OpEqPtr_0(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -10918,7 +10946,7 @@ func rewriteValueARM64_OpEqPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq16(v *Value) bool { +func rewriteValueARM64_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10941,7 +10969,7 @@ func rewriteValueARM64_OpGeq16(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq16U(v *Value) bool { +func rewriteValueARM64_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10964,7 +10992,7 @@ func rewriteValueARM64_OpGeq16U(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq32(v *Value) bool { +func rewriteValueARM64_OpGeq32_0(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -10981,7 +11009,7 @@ func rewriteValueARM64_OpGeq32(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq32F(v *Value) bool { +func rewriteValueARM64_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -10998,7 +11026,7 @@ func rewriteValueARM64_OpGeq32F(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq32U(v *Value) bool { +func rewriteValueARM64_OpGeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -11015,7 +11043,7 @@ func rewriteValueARM64_OpGeq32U(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq64(v *Value) bool { +func rewriteValueARM64_OpGeq64_0(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -11032,7 +11060,7 @@ func rewriteValueARM64_OpGeq64(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq64F(v *Value) bool { +func rewriteValueARM64_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -11049,7 +11077,7 @@ func rewriteValueARM64_OpGeq64F(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq64U(v *Value) bool { +func rewriteValueARM64_OpGeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -11066,7 +11094,7 @@ func rewriteValueARM64_OpGeq64U(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq8(v *Value) bool { +func rewriteValueARM64_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11089,7 +11117,7 @@ func rewriteValueARM64_OpGeq8(v *Value) bool { return true } } -func rewriteValueARM64_OpGeq8U(v *Value) bool { +func rewriteValueARM64_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11112,7 +11140,7 @@ func rewriteValueARM64_OpGeq8U(v *Value) bool { return true } } -func rewriteValueARM64_OpGetClosurePtr(v *Value) bool { +func rewriteValueARM64_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -11121,7 +11149,7 @@ func rewriteValueARM64_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater16(v *Value) bool { +func rewriteValueARM64_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11144,7 +11172,7 @@ func rewriteValueARM64_OpGreater16(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater16U(v *Value) bool { +func rewriteValueARM64_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11167,7 +11195,7 @@ func rewriteValueARM64_OpGreater16U(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater32(v *Value) bool { +func rewriteValueARM64_OpGreater32_0(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -11184,7 +11212,7 @@ func rewriteValueARM64_OpGreater32(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater32F(v *Value) bool { +func rewriteValueARM64_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -11201,7 +11229,7 @@ func rewriteValueARM64_OpGreater32F(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater32U(v *Value) bool { +func rewriteValueARM64_OpGreater32U_0(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -11218,7 +11246,7 @@ func rewriteValueARM64_OpGreater32U(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater64(v *Value) bool { +func rewriteValueARM64_OpGreater64_0(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -11235,7 +11263,7 @@ func rewriteValueARM64_OpGreater64(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater64F(v *Value) bool { +func rewriteValueARM64_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -11252,7 +11280,7 @@ func rewriteValueARM64_OpGreater64F(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater64U(v *Value) bool { +func rewriteValueARM64_OpGreater64U_0(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -11269,7 +11297,7 @@ func rewriteValueARM64_OpGreater64U(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater8(v *Value) bool { +func rewriteValueARM64_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11292,7 +11320,7 @@ func rewriteValueARM64_OpGreater8(v *Value) bool { return true } } -func rewriteValueARM64_OpGreater8U(v *Value) bool { +func rewriteValueARM64_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11315,7 +11343,7 @@ func rewriteValueARM64_OpGreater8U(v *Value) bool { return true } } -func rewriteValueARM64_OpHmul32(v *Value) bool { +func rewriteValueARM64_OpHmul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11335,7 +11363,7 @@ func rewriteValueARM64_OpHmul32(v *Value) bool { return true } } -func rewriteValueARM64_OpHmul32u(v *Value) bool { +func rewriteValueARM64_OpHmul32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11355,7 +11383,7 @@ func rewriteValueARM64_OpHmul32u(v *Value) bool { return true } } -func rewriteValueARM64_OpHmul64(v *Value) bool { +func rewriteValueARM64_OpHmul64_0(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULH x y) @@ -11368,7 +11396,7 @@ func rewriteValueARM64_OpHmul64(v *Value) bool { return true } } -func rewriteValueARM64_OpHmul64u(v *Value) bool { +func rewriteValueARM64_OpHmul64u_0(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (UMULH x y) @@ -11381,7 +11409,7 @@ func rewriteValueARM64_OpHmul64u(v *Value) bool { return true } } -func rewriteValueARM64_OpInterCall(v *Value) bool { +func rewriteValueARM64_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -11396,7 +11424,7 @@ func rewriteValueARM64_OpInterCall(v *Value) bool { return true } } -func rewriteValueARM64_OpIsInBounds(v *Value) bool { +func rewriteValueARM64_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -11413,7 +11441,7 @@ func rewriteValueARM64_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueARM64_OpIsNonNil(v *Value) bool { +func rewriteValueARM64_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -11429,7 +11457,7 @@ func rewriteValueARM64_OpIsNonNil(v *Value) bool { return true } } -func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool { +func rewriteValueARM64_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -11446,7 +11474,7 @@ func rewriteValueARM64_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq16(v *Value) bool { +func rewriteValueARM64_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11469,7 +11497,7 @@ func rewriteValueARM64_OpLeq16(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq16U(v *Value) bool { +func rewriteValueARM64_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11492,7 +11520,7 @@ func rewriteValueARM64_OpLeq16U(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq32(v *Value) bool { +func rewriteValueARM64_OpLeq32_0(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -11509,7 +11537,7 @@ func rewriteValueARM64_OpLeq32(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq32F(v *Value) bool { +func rewriteValueARM64_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -11526,7 +11554,7 @@ func rewriteValueARM64_OpLeq32F(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq32U(v *Value) bool { +func rewriteValueARM64_OpLeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -11543,7 +11571,7 @@ func rewriteValueARM64_OpLeq32U(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq64(v *Value) bool { +func rewriteValueARM64_OpLeq64_0(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -11560,7 +11588,7 @@ func rewriteValueARM64_OpLeq64(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq64F(v *Value) bool { +func rewriteValueARM64_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -11577,7 +11605,7 @@ func rewriteValueARM64_OpLeq64F(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq64U(v *Value) bool { +func rewriteValueARM64_OpLeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -11594,7 +11622,7 @@ func rewriteValueARM64_OpLeq64U(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq8(v *Value) bool { +func rewriteValueARM64_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11617,7 +11645,7 @@ func rewriteValueARM64_OpLeq8(v *Value) bool { return true } } -func rewriteValueARM64_OpLeq8U(v *Value) bool { +func rewriteValueARM64_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11640,7 +11668,7 @@ func rewriteValueARM64_OpLeq8U(v *Value) bool { return true } } -func rewriteValueARM64_OpLess16(v *Value) bool { +func rewriteValueARM64_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11663,7 +11691,7 @@ func rewriteValueARM64_OpLess16(v *Value) bool { return true } } -func rewriteValueARM64_OpLess16U(v *Value) bool { +func rewriteValueARM64_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11686,7 +11714,7 @@ func rewriteValueARM64_OpLess16U(v *Value) bool { return true } } -func rewriteValueARM64_OpLess32(v *Value) bool { +func rewriteValueARM64_OpLess32_0(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -11703,7 +11731,7 @@ func rewriteValueARM64_OpLess32(v *Value) bool { return true } } -func rewriteValueARM64_OpLess32F(v *Value) bool { +func rewriteValueARM64_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -11720,7 +11748,7 @@ func rewriteValueARM64_OpLess32F(v *Value) bool { return true } } -func rewriteValueARM64_OpLess32U(v *Value) bool { +func rewriteValueARM64_OpLess32U_0(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -11737,7 +11765,7 @@ func rewriteValueARM64_OpLess32U(v *Value) bool { return true } } -func rewriteValueARM64_OpLess64(v *Value) bool { +func rewriteValueARM64_OpLess64_0(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -11754,7 +11782,7 @@ func rewriteValueARM64_OpLess64(v *Value) bool { return true } } -func rewriteValueARM64_OpLess64F(v *Value) bool { +func rewriteValueARM64_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -11771,7 +11799,7 @@ func rewriteValueARM64_OpLess64F(v *Value) bool { return true } } -func rewriteValueARM64_OpLess64U(v *Value) bool { +func rewriteValueARM64_OpLess64U_0(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -11788,7 +11816,7 @@ func rewriteValueARM64_OpLess64U(v *Value) bool { return true } } -func rewriteValueARM64_OpLess8(v *Value) bool { +func rewriteValueARM64_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11811,7 +11839,7 @@ func rewriteValueARM64_OpLess8(v *Value) bool { return true } } -func rewriteValueARM64_OpLess8U(v *Value) bool { +func rewriteValueARM64_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11834,7 +11862,7 @@ func rewriteValueARM64_OpLess8U(v *Value) bool { return true } } -func rewriteValueARM64_OpLoad(v *Value) bool { +func rewriteValueARM64_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -11987,7 +12015,7 @@ func rewriteValueARM64_OpLoad(v *Value) bool { } return false } -func rewriteValueARM64_OpLsh16x16(v *Value) bool { +func rewriteValueARM64_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12018,7 +12046,7 @@ func rewriteValueARM64_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh16x32(v *Value) bool { +func rewriteValueARM64_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12049,7 +12077,7 @@ func rewriteValueARM64_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh16x64(v *Value) bool { +func rewriteValueARM64_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 x (MOVDconst [c])) @@ -12108,7 +12136,7 @@ func rewriteValueARM64_OpLsh16x64(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh16x8(v *Value) bool { +func rewriteValueARM64_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12139,7 +12167,7 @@ func rewriteValueARM64_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh32x16(v *Value) bool { +func rewriteValueARM64_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12170,7 +12198,7 @@ func rewriteValueARM64_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh32x32(v *Value) bool { +func rewriteValueARM64_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12201,7 +12229,7 @@ func rewriteValueARM64_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh32x64(v *Value) bool { +func rewriteValueARM64_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 x (MOVDconst [c])) @@ -12260,7 +12288,7 @@ func rewriteValueARM64_OpLsh32x64(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh32x8(v *Value) bool { +func rewriteValueARM64_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12291,7 +12319,7 @@ func rewriteValueARM64_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh64x16(v *Value) bool { +func rewriteValueARM64_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12322,7 +12350,7 @@ func rewriteValueARM64_OpLsh64x16(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh64x32(v *Value) bool { +func rewriteValueARM64_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12353,7 +12381,7 @@ func rewriteValueARM64_OpLsh64x32(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh64x64(v *Value) bool { +func rewriteValueARM64_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 x (MOVDconst [c])) @@ -12412,7 +12440,7 @@ func rewriteValueARM64_OpLsh64x64(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh64x8(v *Value) bool { +func rewriteValueARM64_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12443,7 +12471,7 @@ func rewriteValueARM64_OpLsh64x8(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh8x16(v *Value) bool { +func rewriteValueARM64_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12474,7 +12502,7 @@ func rewriteValueARM64_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh8x32(v *Value) bool { +func rewriteValueARM64_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12505,7 +12533,7 @@ func rewriteValueARM64_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh8x64(v *Value) bool { +func rewriteValueARM64_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 x (MOVDconst [c])) @@ -12564,7 +12592,7 @@ func rewriteValueARM64_OpLsh8x64(v *Value) bool { return true } } -func rewriteValueARM64_OpLsh8x8(v *Value) bool { +func rewriteValueARM64_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12595,7 +12623,7 @@ func rewriteValueARM64_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueARM64_OpMod16(v *Value) bool { +func rewriteValueARM64_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12616,7 +12644,7 @@ func rewriteValueARM64_OpMod16(v *Value) bool { return true } } -func rewriteValueARM64_OpMod16u(v *Value) bool { +func rewriteValueARM64_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12637,7 +12665,7 @@ func rewriteValueARM64_OpMod16u(v *Value) bool { return true } } -func rewriteValueARM64_OpMod32(v *Value) bool { +func rewriteValueARM64_OpMod32_0(v *Value) bool { // match: (Mod32 x y) // cond: // result: (MODW x y) @@ -12650,7 +12678,7 @@ func rewriteValueARM64_OpMod32(v *Value) bool { return true } } -func rewriteValueARM64_OpMod32u(v *Value) bool { +func rewriteValueARM64_OpMod32u_0(v *Value) bool { // match: (Mod32u x y) // cond: // result: (UMODW x y) @@ -12663,7 +12691,7 @@ func rewriteValueARM64_OpMod32u(v *Value) bool { return true } } -func rewriteValueARM64_OpMod64(v *Value) bool { +func rewriteValueARM64_OpMod64_0(v *Value) bool { // match: (Mod64 x y) // cond: // result: (MOD x y) @@ -12676,7 +12704,7 @@ func rewriteValueARM64_OpMod64(v *Value) bool { return true } } -func rewriteValueARM64_OpMod64u(v *Value) bool { +func rewriteValueARM64_OpMod64u_0(v *Value) bool { // match: (Mod64u x y) // cond: // result: (UMOD x y) @@ -12689,7 +12717,7 @@ func rewriteValueARM64_OpMod64u(v *Value) bool { return true } } -func rewriteValueARM64_OpMod8(v *Value) bool { +func rewriteValueARM64_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12710,7 +12738,7 @@ func rewriteValueARM64_OpMod8(v *Value) bool { return true } } -func rewriteValueARM64_OpMod8u(v *Value) bool { +func rewriteValueARM64_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12731,11 +12759,9 @@ func rewriteValueARM64_OpMod8u(v *Value) bool { return true } } -func rewriteValueARM64_OpMove(v *Value) bool { +func rewriteValueARM64_OpMove_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Move [0] _ _ mem) @@ -12976,6 +13002,15 @@ func rewriteValueARM64_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueARM64_OpMove_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Move [16] dst src mem) // cond: // result: (MOVDstore [8] dst (MOVDload [8] src mem) (MOVDstore dst (MOVDload src mem) mem)) @@ -13111,7 +13146,7 @@ func rewriteValueARM64_OpMove(v *Value) bool { } return false } -func rewriteValueARM64_OpMul16(v *Value) bool { +func rewriteValueARM64_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULW x y) @@ -13124,7 +13159,7 @@ func rewriteValueARM64_OpMul16(v *Value) bool { return true } } -func rewriteValueARM64_OpMul32(v *Value) bool { +func rewriteValueARM64_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULW x y) @@ -13137,7 +13172,7 @@ func rewriteValueARM64_OpMul32(v *Value) bool { return true } } -func rewriteValueARM64_OpMul32F(v *Value) bool { +func rewriteValueARM64_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -13150,7 +13185,7 @@ func rewriteValueARM64_OpMul32F(v *Value) bool { return true } } -func rewriteValueARM64_OpMul64(v *Value) bool { +func rewriteValueARM64_OpMul64_0(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MUL x y) @@ -13163,7 +13198,7 @@ func rewriteValueARM64_OpMul64(v *Value) bool { return true } } -func rewriteValueARM64_OpMul64F(v *Value) bool { +func rewriteValueARM64_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMULD x y) @@ -13176,7 +13211,7 @@ func rewriteValueARM64_OpMul64F(v *Value) bool { return true } } -func rewriteValueARM64_OpMul8(v *Value) bool { +func rewriteValueARM64_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULW x y) @@ -13189,7 +13224,7 @@ func rewriteValueARM64_OpMul8(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg16(v *Value) bool { +func rewriteValueARM64_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -13200,7 +13235,7 @@ func rewriteValueARM64_OpNeg16(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg32(v *Value) bool { +func rewriteValueARM64_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -13211,7 +13246,7 @@ func rewriteValueARM64_OpNeg32(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg32F(v *Value) bool { +func rewriteValueARM64_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEGS x) @@ -13222,7 +13257,7 @@ func rewriteValueARM64_OpNeg32F(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg64(v *Value) bool { +func rewriteValueARM64_OpNeg64_0(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -13233,7 +13268,7 @@ func rewriteValueARM64_OpNeg64(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg64F(v *Value) bool { +func rewriteValueARM64_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEGD x) @@ -13244,7 +13279,7 @@ func rewriteValueARM64_OpNeg64F(v *Value) bool { return true } } -func rewriteValueARM64_OpNeg8(v *Value) bool { +func rewriteValueARM64_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -13255,7 +13290,7 @@ func rewriteValueARM64_OpNeg8(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq16(v *Value) bool { +func rewriteValueARM64_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13278,7 +13313,7 @@ func rewriteValueARM64_OpNeq16(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq32(v *Value) bool { +func rewriteValueARM64_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -13295,7 +13330,7 @@ func rewriteValueARM64_OpNeq32(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq32F(v *Value) bool { +func rewriteValueARM64_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -13312,7 +13347,7 @@ func rewriteValueARM64_OpNeq32F(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq64(v *Value) bool { +func rewriteValueARM64_OpNeq64_0(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -13329,7 +13364,7 @@ func rewriteValueARM64_OpNeq64(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq64F(v *Value) bool { +func rewriteValueARM64_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -13346,7 +13381,7 @@ func rewriteValueARM64_OpNeq64F(v *Value) bool { return true } } -func rewriteValueARM64_OpNeq8(v *Value) bool { +func rewriteValueARM64_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13369,7 +13404,7 @@ func rewriteValueARM64_OpNeq8(v *Value) bool { return true } } -func rewriteValueARM64_OpNeqB(v *Value) bool { +func rewriteValueARM64_OpNeqB_0(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -13382,7 +13417,7 @@ func rewriteValueARM64_OpNeqB(v *Value) bool { return true } } -func rewriteValueARM64_OpNeqPtr(v *Value) bool { +func rewriteValueARM64_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -13399,7 +13434,7 @@ func rewriteValueARM64_OpNeqPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpNilCheck(v *Value) bool { +func rewriteValueARM64_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -13412,7 +13447,7 @@ func rewriteValueARM64_OpNilCheck(v *Value) bool { return true } } -func rewriteValueARM64_OpNot(v *Value) bool { +func rewriteValueARM64_OpNot_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13430,7 +13465,7 @@ func rewriteValueARM64_OpNot(v *Value) bool { return true } } -func rewriteValueARM64_OpOffPtr(v *Value) bool { +func rewriteValueARM64_OpOffPtr_0(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVDaddr [off] ptr) @@ -13457,7 +13492,7 @@ func rewriteValueARM64_OpOffPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpOr16(v *Value) bool { +func rewriteValueARM64_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -13470,7 +13505,7 @@ func rewriteValueARM64_OpOr16(v *Value) bool { return true } } -func rewriteValueARM64_OpOr32(v *Value) bool { +func rewriteValueARM64_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -13483,7 +13518,7 @@ func rewriteValueARM64_OpOr32(v *Value) bool { return true } } -func rewriteValueARM64_OpOr64(v *Value) bool { +func rewriteValueARM64_OpOr64_0(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -13496,7 +13531,7 @@ func rewriteValueARM64_OpOr64(v *Value) bool { return true } } -func rewriteValueARM64_OpOr8(v *Value) bool { +func rewriteValueARM64_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -13509,7 +13544,7 @@ func rewriteValueARM64_OpOr8(v *Value) bool { return true } } -func rewriteValueARM64_OpOrB(v *Value) bool { +func rewriteValueARM64_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -13522,7 +13557,7 @@ func rewriteValueARM64_OpOrB(v *Value) bool { return true } } -func rewriteValueARM64_OpRound32F(v *Value) bool { +func rewriteValueARM64_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -13534,7 +13569,7 @@ func rewriteValueARM64_OpRound32F(v *Value) bool { return true } } -func rewriteValueARM64_OpRound64F(v *Value) bool { +func rewriteValueARM64_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -13546,7 +13581,7 @@ func rewriteValueARM64_OpRound64F(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16Ux16(v *Value) bool { +func rewriteValueARM64_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13579,7 +13614,7 @@ func rewriteValueARM64_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16Ux32(v *Value) bool { +func rewriteValueARM64_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13612,7 +13647,7 @@ func rewriteValueARM64_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16Ux64(v *Value) bool { +func rewriteValueARM64_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13677,7 +13712,7 @@ func rewriteValueARM64_OpRsh16Ux64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16Ux8(v *Value) bool { +func rewriteValueARM64_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13710,7 +13745,7 @@ func rewriteValueARM64_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16x16(v *Value) bool { +func rewriteValueARM64_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13742,7 +13777,7 @@ func rewriteValueARM64_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16x32(v *Value) bool { +func rewriteValueARM64_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13774,7 +13809,7 @@ func rewriteValueARM64_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16x64(v *Value) bool { +func rewriteValueARM64_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13842,7 +13877,7 @@ func rewriteValueARM64_OpRsh16x64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh16x8(v *Value) bool { +func rewriteValueARM64_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13874,7 +13909,7 @@ func rewriteValueARM64_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32Ux16(v *Value) bool { +func rewriteValueARM64_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13907,7 +13942,7 @@ func rewriteValueARM64_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32Ux32(v *Value) bool { +func rewriteValueARM64_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13940,7 +13975,7 @@ func rewriteValueARM64_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32Ux64(v *Value) bool { +func rewriteValueARM64_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14005,7 +14040,7 @@ func rewriteValueARM64_OpRsh32Ux64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32Ux8(v *Value) bool { +func rewriteValueARM64_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14038,7 +14073,7 @@ func rewriteValueARM64_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32x16(v *Value) bool { +func rewriteValueARM64_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14070,7 +14105,7 @@ func rewriteValueARM64_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32x32(v *Value) bool { +func rewriteValueARM64_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14102,7 +14137,7 @@ func rewriteValueARM64_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32x64(v *Value) bool { +func rewriteValueARM64_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14170,7 +14205,7 @@ func rewriteValueARM64_OpRsh32x64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh32x8(v *Value) bool { +func rewriteValueARM64_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14202,7 +14237,7 @@ func rewriteValueARM64_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64Ux16(v *Value) bool { +func rewriteValueARM64_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14233,7 +14268,7 @@ func rewriteValueARM64_OpRsh64Ux16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64Ux32(v *Value) bool { +func rewriteValueARM64_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14264,7 +14299,7 @@ func rewriteValueARM64_OpRsh64Ux32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64Ux64(v *Value) bool { +func rewriteValueARM64_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 x (MOVDconst [c])) @@ -14323,7 +14358,7 @@ func rewriteValueARM64_OpRsh64Ux64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64Ux8(v *Value) bool { +func rewriteValueARM64_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14354,7 +14389,7 @@ func rewriteValueARM64_OpRsh64Ux8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64x16(v *Value) bool { +func rewriteValueARM64_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14384,7 +14419,7 @@ func rewriteValueARM64_OpRsh64x16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64x32(v *Value) bool { +func rewriteValueARM64_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14414,7 +14449,7 @@ func rewriteValueARM64_OpRsh64x32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64x64(v *Value) bool { +func rewriteValueARM64_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 x (MOVDconst [c])) @@ -14474,7 +14509,7 @@ func rewriteValueARM64_OpRsh64x64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh64x8(v *Value) bool { +func rewriteValueARM64_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14504,7 +14539,7 @@ func rewriteValueARM64_OpRsh64x8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8Ux16(v *Value) bool { +func rewriteValueARM64_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14537,7 +14572,7 @@ func rewriteValueARM64_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8Ux32(v *Value) bool { +func rewriteValueARM64_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14570,7 +14605,7 @@ func rewriteValueARM64_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8Ux64(v *Value) bool { +func rewriteValueARM64_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14635,7 +14670,7 @@ func rewriteValueARM64_OpRsh8Ux64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8Ux8(v *Value) bool { +func rewriteValueARM64_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14668,7 +14703,7 @@ func rewriteValueARM64_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8x16(v *Value) bool { +func rewriteValueARM64_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14700,7 +14735,7 @@ func rewriteValueARM64_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8x32(v *Value) bool { +func rewriteValueARM64_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14732,7 +14767,7 @@ func rewriteValueARM64_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8x64(v *Value) bool { +func rewriteValueARM64_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14800,7 +14835,7 @@ func rewriteValueARM64_OpRsh8x64(v *Value) bool { return true } } -func rewriteValueARM64_OpRsh8x8(v *Value) bool { +func rewriteValueARM64_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14832,7 +14867,7 @@ func rewriteValueARM64_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt16to32(v *Value) bool { +func rewriteValueARM64_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -14843,7 +14878,7 @@ func rewriteValueARM64_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt16to64(v *Value) bool { +func rewriteValueARM64_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -14854,7 +14889,7 @@ func rewriteValueARM64_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt32to64(v *Value) bool { +func rewriteValueARM64_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -14865,7 +14900,7 @@ func rewriteValueARM64_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt8to16(v *Value) bool { +func rewriteValueARM64_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -14876,7 +14911,7 @@ func rewriteValueARM64_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt8to32(v *Value) bool { +func rewriteValueARM64_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -14887,7 +14922,7 @@ func rewriteValueARM64_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueARM64_OpSignExt8to64(v *Value) bool { +func rewriteValueARM64_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -14898,7 +14933,7 @@ func rewriteValueARM64_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValueARM64_OpSlicemask(v *Value) bool { +func rewriteValueARM64_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -14915,7 +14950,7 @@ func rewriteValueARM64_OpSlicemask(v *Value) bool { return true } } -func rewriteValueARM64_OpSqrt(v *Value) bool { +func rewriteValueARM64_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRTD x) @@ -14926,7 +14961,7 @@ func rewriteValueARM64_OpSqrt(v *Value) bool { return true } } -func rewriteValueARM64_OpStaticCall(v *Value) bool { +func rewriteValueARM64_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -14941,7 +14976,7 @@ func rewriteValueARM64_OpStaticCall(v *Value) bool { return true } } -func rewriteValueARM64_OpStore(v *Value) bool { +func rewriteValueARM64_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -15046,7 +15081,7 @@ func rewriteValueARM64_OpStore(v *Value) bool { } return false } -func rewriteValueARM64_OpSub16(v *Value) bool { +func rewriteValueARM64_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -15059,7 +15094,7 @@ func rewriteValueARM64_OpSub16(v *Value) bool { return true } } -func rewriteValueARM64_OpSub32(v *Value) bool { +func rewriteValueARM64_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -15072,7 +15107,7 @@ func rewriteValueARM64_OpSub32(v *Value) bool { return true } } -func rewriteValueARM64_OpSub32F(v *Value) bool { +func rewriteValueARM64_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -15085,7 +15120,7 @@ func rewriteValueARM64_OpSub32F(v *Value) bool { return true } } -func rewriteValueARM64_OpSub64(v *Value) bool { +func rewriteValueARM64_OpSub64_0(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -15098,7 +15133,7 @@ func rewriteValueARM64_OpSub64(v *Value) bool { return true } } -func rewriteValueARM64_OpSub64F(v *Value) bool { +func rewriteValueARM64_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUBD x y) @@ -15111,7 +15146,7 @@ func rewriteValueARM64_OpSub64F(v *Value) bool { return true } } -func rewriteValueARM64_OpSub8(v *Value) bool { +func rewriteValueARM64_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -15124,7 +15159,7 @@ func rewriteValueARM64_OpSub8(v *Value) bool { return true } } -func rewriteValueARM64_OpSubPtr(v *Value) bool { +func rewriteValueARM64_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -15137,7 +15172,7 @@ func rewriteValueARM64_OpSubPtr(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc16to8(v *Value) bool { +func rewriteValueARM64_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -15149,7 +15184,7 @@ func rewriteValueARM64_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc32to16(v *Value) bool { +func rewriteValueARM64_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -15161,7 +15196,7 @@ func rewriteValueARM64_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc32to8(v *Value) bool { +func rewriteValueARM64_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -15173,7 +15208,7 @@ func rewriteValueARM64_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc64to16(v *Value) bool { +func rewriteValueARM64_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -15185,7 +15220,7 @@ func rewriteValueARM64_OpTrunc64to16(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc64to32(v *Value) bool { +func rewriteValueARM64_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -15197,7 +15232,7 @@ func rewriteValueARM64_OpTrunc64to32(v *Value) bool { return true } } -func rewriteValueARM64_OpTrunc64to8(v *Value) bool { +func rewriteValueARM64_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -15209,7 +15244,7 @@ func rewriteValueARM64_OpTrunc64to8(v *Value) bool { return true } } -func rewriteValueARM64_OpXor16(v *Value) bool { +func rewriteValueARM64_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -15222,7 +15257,7 @@ func rewriteValueARM64_OpXor16(v *Value) bool { return true } } -func rewriteValueARM64_OpXor32(v *Value) bool { +func rewriteValueARM64_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -15235,7 +15270,7 @@ func rewriteValueARM64_OpXor32(v *Value) bool { return true } } -func rewriteValueARM64_OpXor64(v *Value) bool { +func rewriteValueARM64_OpXor64_0(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -15248,7 +15283,7 @@ func rewriteValueARM64_OpXor64(v *Value) bool { return true } } -func rewriteValueARM64_OpXor8(v *Value) bool { +func rewriteValueARM64_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -15261,11 +15296,9 @@ func rewriteValueARM64_OpXor8(v *Value) bool { return true } } -func rewriteValueARM64_OpZero(v *Value) bool { +func rewriteValueARM64_OpZero_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Zero [0] _ mem) @@ -15476,6 +15509,15 @@ func rewriteValueARM64_OpZero(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueARM64_OpZero_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Zero [16] ptr mem) // cond: // result: (MOVDstore [8] ptr (MOVDconst [0]) (MOVDstore ptr (MOVDconst [0]) mem)) @@ -15591,7 +15633,7 @@ func rewriteValueARM64_OpZero(v *Value) bool { } return false } -func rewriteValueARM64_OpZeroExt16to32(v *Value) bool { +func rewriteValueARM64_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -15602,7 +15644,7 @@ func rewriteValueARM64_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueARM64_OpZeroExt16to64(v *Value) bool { +func rewriteValueARM64_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHUreg x) @@ -15613,7 +15655,7 @@ func rewriteValueARM64_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValueARM64_OpZeroExt32to64(v *Value) bool { +func rewriteValueARM64_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWUreg x) @@ -15624,7 +15666,7 @@ func rewriteValueARM64_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValueARM64_OpZeroExt8to16(v *Value) bool { +func rewriteValueARM64_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -15635,7 +15677,7 @@ func rewriteValueARM64_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueARM64_OpZeroExt8to32(v *Value) bool { +func rewriteValueARM64_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -15646,7 +15688,7 @@ func rewriteValueARM64_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueARM64_OpZeroExt8to64(v *Value) bool { +func rewriteValueARM64_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBUreg x) diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS.go b/src/cmd/compile/internal/ssa/rewriteMIPS.go index 64a6ddfea0..bed923b7e9 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS.go @@ -14,499 +14,499 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueMIPS(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueMIPS_OpAdd16(v) + return rewriteValueMIPS_OpAdd16_0(v) case OpAdd32: - return rewriteValueMIPS_OpAdd32(v) + return rewriteValueMIPS_OpAdd32_0(v) case OpAdd32F: - return rewriteValueMIPS_OpAdd32F(v) + return rewriteValueMIPS_OpAdd32F_0(v) case OpAdd32withcarry: - return rewriteValueMIPS_OpAdd32withcarry(v) + return rewriteValueMIPS_OpAdd32withcarry_0(v) case OpAdd64F: - return rewriteValueMIPS_OpAdd64F(v) + return rewriteValueMIPS_OpAdd64F_0(v) case OpAdd8: - return rewriteValueMIPS_OpAdd8(v) + return rewriteValueMIPS_OpAdd8_0(v) case OpAddPtr: - return rewriteValueMIPS_OpAddPtr(v) + return rewriteValueMIPS_OpAddPtr_0(v) case OpAddr: - return rewriteValueMIPS_OpAddr(v) + return rewriteValueMIPS_OpAddr_0(v) case OpAnd16: - return rewriteValueMIPS_OpAnd16(v) + return rewriteValueMIPS_OpAnd16_0(v) case OpAnd32: - return rewriteValueMIPS_OpAnd32(v) + return rewriteValueMIPS_OpAnd32_0(v) case OpAnd8: - return rewriteValueMIPS_OpAnd8(v) + return rewriteValueMIPS_OpAnd8_0(v) case OpAndB: - return rewriteValueMIPS_OpAndB(v) + return rewriteValueMIPS_OpAndB_0(v) case OpAtomicAdd32: - return rewriteValueMIPS_OpAtomicAdd32(v) + return rewriteValueMIPS_OpAtomicAdd32_0(v) case OpAtomicAnd8: - return rewriteValueMIPS_OpAtomicAnd8(v) + return rewriteValueMIPS_OpAtomicAnd8_0(v) case OpAtomicCompareAndSwap32: - return rewriteValueMIPS_OpAtomicCompareAndSwap32(v) + return rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v) case OpAtomicExchange32: - return rewriteValueMIPS_OpAtomicExchange32(v) + return rewriteValueMIPS_OpAtomicExchange32_0(v) case OpAtomicLoad32: - return rewriteValueMIPS_OpAtomicLoad32(v) + return rewriteValueMIPS_OpAtomicLoad32_0(v) case OpAtomicLoadPtr: - return rewriteValueMIPS_OpAtomicLoadPtr(v) + return rewriteValueMIPS_OpAtomicLoadPtr_0(v) case OpAtomicOr8: - return rewriteValueMIPS_OpAtomicOr8(v) + return rewriteValueMIPS_OpAtomicOr8_0(v) case OpAtomicStore32: - return rewriteValueMIPS_OpAtomicStore32(v) + return rewriteValueMIPS_OpAtomicStore32_0(v) case OpAtomicStorePtrNoWB: - return rewriteValueMIPS_OpAtomicStorePtrNoWB(v) + return rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v) case OpAvg32u: - return rewriteValueMIPS_OpAvg32u(v) + return rewriteValueMIPS_OpAvg32u_0(v) case OpBitLen32: - return rewriteValueMIPS_OpBitLen32(v) + return rewriteValueMIPS_OpBitLen32_0(v) case OpClosureCall: - return rewriteValueMIPS_OpClosureCall(v) + return rewriteValueMIPS_OpClosureCall_0(v) case OpCom16: - return rewriteValueMIPS_OpCom16(v) + return rewriteValueMIPS_OpCom16_0(v) case OpCom32: - return rewriteValueMIPS_OpCom32(v) + return rewriteValueMIPS_OpCom32_0(v) case OpCom8: - return rewriteValueMIPS_OpCom8(v) + return rewriteValueMIPS_OpCom8_0(v) case OpConst16: - return rewriteValueMIPS_OpConst16(v) + return rewriteValueMIPS_OpConst16_0(v) case OpConst32: - return rewriteValueMIPS_OpConst32(v) + return rewriteValueMIPS_OpConst32_0(v) case OpConst32F: - return rewriteValueMIPS_OpConst32F(v) + return rewriteValueMIPS_OpConst32F_0(v) case OpConst64F: - return rewriteValueMIPS_OpConst64F(v) + return rewriteValueMIPS_OpConst64F_0(v) case OpConst8: - return rewriteValueMIPS_OpConst8(v) + return rewriteValueMIPS_OpConst8_0(v) case OpConstBool: - return rewriteValueMIPS_OpConstBool(v) + return rewriteValueMIPS_OpConstBool_0(v) case OpConstNil: - return rewriteValueMIPS_OpConstNil(v) + return rewriteValueMIPS_OpConstNil_0(v) case OpConvert: - return rewriteValueMIPS_OpConvert(v) + return rewriteValueMIPS_OpConvert_0(v) case OpCtz32: - return rewriteValueMIPS_OpCtz32(v) + return rewriteValueMIPS_OpCtz32_0(v) case OpCvt32Fto32: - return rewriteValueMIPS_OpCvt32Fto32(v) + return rewriteValueMIPS_OpCvt32Fto32_0(v) case OpCvt32Fto64F: - return rewriteValueMIPS_OpCvt32Fto64F(v) + return rewriteValueMIPS_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValueMIPS_OpCvt32to32F(v) + return rewriteValueMIPS_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueMIPS_OpCvt32to64F(v) + return rewriteValueMIPS_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueMIPS_OpCvt64Fto32(v) + return rewriteValueMIPS_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueMIPS_OpCvt64Fto32F(v) + return rewriteValueMIPS_OpCvt64Fto32F_0(v) case OpDiv16: - return rewriteValueMIPS_OpDiv16(v) + return rewriteValueMIPS_OpDiv16_0(v) case OpDiv16u: - return rewriteValueMIPS_OpDiv16u(v) + return rewriteValueMIPS_OpDiv16u_0(v) case OpDiv32: - return rewriteValueMIPS_OpDiv32(v) + return rewriteValueMIPS_OpDiv32_0(v) case OpDiv32F: - return rewriteValueMIPS_OpDiv32F(v) + return rewriteValueMIPS_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueMIPS_OpDiv32u(v) + return rewriteValueMIPS_OpDiv32u_0(v) case OpDiv64F: - return rewriteValueMIPS_OpDiv64F(v) + return rewriteValueMIPS_OpDiv64F_0(v) case OpDiv8: - return rewriteValueMIPS_OpDiv8(v) + return rewriteValueMIPS_OpDiv8_0(v) case OpDiv8u: - return rewriteValueMIPS_OpDiv8u(v) + return rewriteValueMIPS_OpDiv8u_0(v) case OpEq16: - return rewriteValueMIPS_OpEq16(v) + return rewriteValueMIPS_OpEq16_0(v) case OpEq32: - return rewriteValueMIPS_OpEq32(v) + return rewriteValueMIPS_OpEq32_0(v) case OpEq32F: - return rewriteValueMIPS_OpEq32F(v) + return rewriteValueMIPS_OpEq32F_0(v) case OpEq64F: - return rewriteValueMIPS_OpEq64F(v) + return rewriteValueMIPS_OpEq64F_0(v) case OpEq8: - return rewriteValueMIPS_OpEq8(v) + return rewriteValueMIPS_OpEq8_0(v) case OpEqB: - return rewriteValueMIPS_OpEqB(v) + return rewriteValueMIPS_OpEqB_0(v) case OpEqPtr: - return rewriteValueMIPS_OpEqPtr(v) + return rewriteValueMIPS_OpEqPtr_0(v) case OpGeq16: - return rewriteValueMIPS_OpGeq16(v) + return rewriteValueMIPS_OpGeq16_0(v) case OpGeq16U: - return rewriteValueMIPS_OpGeq16U(v) + return rewriteValueMIPS_OpGeq16U_0(v) case OpGeq32: - return rewriteValueMIPS_OpGeq32(v) + return rewriteValueMIPS_OpGeq32_0(v) case OpGeq32F: - return rewriteValueMIPS_OpGeq32F(v) + return rewriteValueMIPS_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueMIPS_OpGeq32U(v) + return rewriteValueMIPS_OpGeq32U_0(v) case OpGeq64F: - return rewriteValueMIPS_OpGeq64F(v) + return rewriteValueMIPS_OpGeq64F_0(v) case OpGeq8: - return rewriteValueMIPS_OpGeq8(v) + return rewriteValueMIPS_OpGeq8_0(v) case OpGeq8U: - return rewriteValueMIPS_OpGeq8U(v) + return rewriteValueMIPS_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueMIPS_OpGetClosurePtr(v) + return rewriteValueMIPS_OpGetClosurePtr_0(v) case OpGreater16: - return rewriteValueMIPS_OpGreater16(v) + return rewriteValueMIPS_OpGreater16_0(v) case OpGreater16U: - return rewriteValueMIPS_OpGreater16U(v) + return rewriteValueMIPS_OpGreater16U_0(v) case OpGreater32: - return rewriteValueMIPS_OpGreater32(v) + return rewriteValueMIPS_OpGreater32_0(v) case OpGreater32F: - return rewriteValueMIPS_OpGreater32F(v) + return rewriteValueMIPS_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueMIPS_OpGreater32U(v) + return rewriteValueMIPS_OpGreater32U_0(v) case OpGreater64F: - return rewriteValueMIPS_OpGreater64F(v) + return rewriteValueMIPS_OpGreater64F_0(v) case OpGreater8: - return rewriteValueMIPS_OpGreater8(v) + return rewriteValueMIPS_OpGreater8_0(v) case OpGreater8U: - return rewriteValueMIPS_OpGreater8U(v) + return rewriteValueMIPS_OpGreater8U_0(v) case OpHmul32: - return rewriteValueMIPS_OpHmul32(v) + return rewriteValueMIPS_OpHmul32_0(v) case OpHmul32u: - return rewriteValueMIPS_OpHmul32u(v) + return rewriteValueMIPS_OpHmul32u_0(v) case OpInterCall: - return rewriteValueMIPS_OpInterCall(v) + return rewriteValueMIPS_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueMIPS_OpIsInBounds(v) + return rewriteValueMIPS_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueMIPS_OpIsNonNil(v) + return rewriteValueMIPS_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueMIPS_OpIsSliceInBounds(v) + return rewriteValueMIPS_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueMIPS_OpLeq16(v) + return rewriteValueMIPS_OpLeq16_0(v) case OpLeq16U: - return rewriteValueMIPS_OpLeq16U(v) + return rewriteValueMIPS_OpLeq16U_0(v) case OpLeq32: - return rewriteValueMIPS_OpLeq32(v) + return rewriteValueMIPS_OpLeq32_0(v) case OpLeq32F: - return rewriteValueMIPS_OpLeq32F(v) + return rewriteValueMIPS_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueMIPS_OpLeq32U(v) + return rewriteValueMIPS_OpLeq32U_0(v) case OpLeq64F: - return rewriteValueMIPS_OpLeq64F(v) + return rewriteValueMIPS_OpLeq64F_0(v) case OpLeq8: - return rewriteValueMIPS_OpLeq8(v) + return rewriteValueMIPS_OpLeq8_0(v) case OpLeq8U: - return rewriteValueMIPS_OpLeq8U(v) + return rewriteValueMIPS_OpLeq8U_0(v) case OpLess16: - return rewriteValueMIPS_OpLess16(v) + return rewriteValueMIPS_OpLess16_0(v) case OpLess16U: - return rewriteValueMIPS_OpLess16U(v) + return rewriteValueMIPS_OpLess16U_0(v) case OpLess32: - return rewriteValueMIPS_OpLess32(v) + return rewriteValueMIPS_OpLess32_0(v) case OpLess32F: - return rewriteValueMIPS_OpLess32F(v) + return rewriteValueMIPS_OpLess32F_0(v) case OpLess32U: - return rewriteValueMIPS_OpLess32U(v) + return rewriteValueMIPS_OpLess32U_0(v) case OpLess64F: - return rewriteValueMIPS_OpLess64F(v) + return rewriteValueMIPS_OpLess64F_0(v) case OpLess8: - return rewriteValueMIPS_OpLess8(v) + return rewriteValueMIPS_OpLess8_0(v) case OpLess8U: - return rewriteValueMIPS_OpLess8U(v) + return rewriteValueMIPS_OpLess8U_0(v) case OpLoad: - return rewriteValueMIPS_OpLoad(v) + return rewriteValueMIPS_OpLoad_0(v) case OpLsh16x16: - return rewriteValueMIPS_OpLsh16x16(v) + return rewriteValueMIPS_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueMIPS_OpLsh16x32(v) + return rewriteValueMIPS_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueMIPS_OpLsh16x64(v) + return rewriteValueMIPS_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueMIPS_OpLsh16x8(v) + return rewriteValueMIPS_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueMIPS_OpLsh32x16(v) + return rewriteValueMIPS_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueMIPS_OpLsh32x32(v) + return rewriteValueMIPS_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueMIPS_OpLsh32x64(v) + return rewriteValueMIPS_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueMIPS_OpLsh32x8(v) + return rewriteValueMIPS_OpLsh32x8_0(v) case OpLsh8x16: - return rewriteValueMIPS_OpLsh8x16(v) + return rewriteValueMIPS_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueMIPS_OpLsh8x32(v) + return rewriteValueMIPS_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueMIPS_OpLsh8x64(v) + return rewriteValueMIPS_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueMIPS_OpLsh8x8(v) + return rewriteValueMIPS_OpLsh8x8_0(v) case OpMIPSADD: - return rewriteValueMIPS_OpMIPSADD(v) + return rewriteValueMIPS_OpMIPSADD_0(v) case OpMIPSADDconst: - return rewriteValueMIPS_OpMIPSADDconst(v) + return rewriteValueMIPS_OpMIPSADDconst_0(v) case OpMIPSAND: - return rewriteValueMIPS_OpMIPSAND(v) + return rewriteValueMIPS_OpMIPSAND_0(v) case OpMIPSANDconst: - return rewriteValueMIPS_OpMIPSANDconst(v) + return rewriteValueMIPS_OpMIPSANDconst_0(v) case OpMIPSCMOVZ: - return rewriteValueMIPS_OpMIPSCMOVZ(v) + return rewriteValueMIPS_OpMIPSCMOVZ_0(v) case OpMIPSCMOVZzero: - return rewriteValueMIPS_OpMIPSCMOVZzero(v) + return rewriteValueMIPS_OpMIPSCMOVZzero_0(v) case OpMIPSLoweredAtomicAdd: - return rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v) + return rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v) case OpMIPSLoweredAtomicStore: - return rewriteValueMIPS_OpMIPSLoweredAtomicStore(v) + return rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v) case OpMIPSMOVBUload: - return rewriteValueMIPS_OpMIPSMOVBUload(v) + return rewriteValueMIPS_OpMIPSMOVBUload_0(v) case OpMIPSMOVBUreg: - return rewriteValueMIPS_OpMIPSMOVBUreg(v) + return rewriteValueMIPS_OpMIPSMOVBUreg_0(v) case OpMIPSMOVBload: - return rewriteValueMIPS_OpMIPSMOVBload(v) + return rewriteValueMIPS_OpMIPSMOVBload_0(v) case OpMIPSMOVBreg: - return rewriteValueMIPS_OpMIPSMOVBreg(v) + return rewriteValueMIPS_OpMIPSMOVBreg_0(v) case OpMIPSMOVBstore: - return rewriteValueMIPS_OpMIPSMOVBstore(v) + return rewriteValueMIPS_OpMIPSMOVBstore_0(v) case OpMIPSMOVBstorezero: - return rewriteValueMIPS_OpMIPSMOVBstorezero(v) + return rewriteValueMIPS_OpMIPSMOVBstorezero_0(v) case OpMIPSMOVDload: - return rewriteValueMIPS_OpMIPSMOVDload(v) + return rewriteValueMIPS_OpMIPSMOVDload_0(v) case OpMIPSMOVDstore: - return rewriteValueMIPS_OpMIPSMOVDstore(v) + return rewriteValueMIPS_OpMIPSMOVDstore_0(v) case OpMIPSMOVFload: - return rewriteValueMIPS_OpMIPSMOVFload(v) + return rewriteValueMIPS_OpMIPSMOVFload_0(v) case OpMIPSMOVFstore: - return rewriteValueMIPS_OpMIPSMOVFstore(v) + return rewriteValueMIPS_OpMIPSMOVFstore_0(v) case OpMIPSMOVHUload: - return rewriteValueMIPS_OpMIPSMOVHUload(v) + return rewriteValueMIPS_OpMIPSMOVHUload_0(v) case OpMIPSMOVHUreg: - return rewriteValueMIPS_OpMIPSMOVHUreg(v) + return rewriteValueMIPS_OpMIPSMOVHUreg_0(v) case OpMIPSMOVHload: - return rewriteValueMIPS_OpMIPSMOVHload(v) + return rewriteValueMIPS_OpMIPSMOVHload_0(v) case OpMIPSMOVHreg: - return rewriteValueMIPS_OpMIPSMOVHreg(v) + return rewriteValueMIPS_OpMIPSMOVHreg_0(v) case OpMIPSMOVHstore: - return rewriteValueMIPS_OpMIPSMOVHstore(v) + return rewriteValueMIPS_OpMIPSMOVHstore_0(v) case OpMIPSMOVHstorezero: - return rewriteValueMIPS_OpMIPSMOVHstorezero(v) + return rewriteValueMIPS_OpMIPSMOVHstorezero_0(v) case OpMIPSMOVWload: - return rewriteValueMIPS_OpMIPSMOVWload(v) + return rewriteValueMIPS_OpMIPSMOVWload_0(v) case OpMIPSMOVWreg: - return rewriteValueMIPS_OpMIPSMOVWreg(v) + return rewriteValueMIPS_OpMIPSMOVWreg_0(v) case OpMIPSMOVWstore: - return rewriteValueMIPS_OpMIPSMOVWstore(v) + return rewriteValueMIPS_OpMIPSMOVWstore_0(v) case OpMIPSMOVWstorezero: - return rewriteValueMIPS_OpMIPSMOVWstorezero(v) + return rewriteValueMIPS_OpMIPSMOVWstorezero_0(v) case OpMIPSMUL: - return rewriteValueMIPS_OpMIPSMUL(v) + return rewriteValueMIPS_OpMIPSMUL_0(v) case OpMIPSNEG: - return rewriteValueMIPS_OpMIPSNEG(v) + return rewriteValueMIPS_OpMIPSNEG_0(v) case OpMIPSNOR: - return rewriteValueMIPS_OpMIPSNOR(v) + return rewriteValueMIPS_OpMIPSNOR_0(v) case OpMIPSNORconst: - return rewriteValueMIPS_OpMIPSNORconst(v) + return rewriteValueMIPS_OpMIPSNORconst_0(v) case OpMIPSOR: - return rewriteValueMIPS_OpMIPSOR(v) + return rewriteValueMIPS_OpMIPSOR_0(v) case OpMIPSORconst: - return rewriteValueMIPS_OpMIPSORconst(v) + return rewriteValueMIPS_OpMIPSORconst_0(v) case OpMIPSSGT: - return rewriteValueMIPS_OpMIPSSGT(v) + return rewriteValueMIPS_OpMIPSSGT_0(v) case OpMIPSSGTU: - return rewriteValueMIPS_OpMIPSSGTU(v) + return rewriteValueMIPS_OpMIPSSGTU_0(v) case OpMIPSSGTUconst: - return rewriteValueMIPS_OpMIPSSGTUconst(v) + return rewriteValueMIPS_OpMIPSSGTUconst_0(v) case OpMIPSSGTUzero: - return rewriteValueMIPS_OpMIPSSGTUzero(v) + return rewriteValueMIPS_OpMIPSSGTUzero_0(v) case OpMIPSSGTconst: - return rewriteValueMIPS_OpMIPSSGTconst(v) + return rewriteValueMIPS_OpMIPSSGTconst_0(v) || rewriteValueMIPS_OpMIPSSGTconst_10(v) case OpMIPSSGTzero: - return rewriteValueMIPS_OpMIPSSGTzero(v) + return rewriteValueMIPS_OpMIPSSGTzero_0(v) case OpMIPSSLL: - return rewriteValueMIPS_OpMIPSSLL(v) + return rewriteValueMIPS_OpMIPSSLL_0(v) case OpMIPSSLLconst: - return rewriteValueMIPS_OpMIPSSLLconst(v) + return rewriteValueMIPS_OpMIPSSLLconst_0(v) case OpMIPSSRA: - return rewriteValueMIPS_OpMIPSSRA(v) + return rewriteValueMIPS_OpMIPSSRA_0(v) case OpMIPSSRAconst: - return rewriteValueMIPS_OpMIPSSRAconst(v) + return rewriteValueMIPS_OpMIPSSRAconst_0(v) case OpMIPSSRL: - return rewriteValueMIPS_OpMIPSSRL(v) + return rewriteValueMIPS_OpMIPSSRL_0(v) case OpMIPSSRLconst: - return rewriteValueMIPS_OpMIPSSRLconst(v) + return rewriteValueMIPS_OpMIPSSRLconst_0(v) case OpMIPSSUB: - return rewriteValueMIPS_OpMIPSSUB(v) + return rewriteValueMIPS_OpMIPSSUB_0(v) case OpMIPSSUBconst: - return rewriteValueMIPS_OpMIPSSUBconst(v) + return rewriteValueMIPS_OpMIPSSUBconst_0(v) case OpMIPSXOR: - return rewriteValueMIPS_OpMIPSXOR(v) + return rewriteValueMIPS_OpMIPSXOR_0(v) case OpMIPSXORconst: - return rewriteValueMIPS_OpMIPSXORconst(v) + return rewriteValueMIPS_OpMIPSXORconst_0(v) case OpMod16: - return rewriteValueMIPS_OpMod16(v) + return rewriteValueMIPS_OpMod16_0(v) case OpMod16u: - return rewriteValueMIPS_OpMod16u(v) + return rewriteValueMIPS_OpMod16u_0(v) case OpMod32: - return rewriteValueMIPS_OpMod32(v) + return rewriteValueMIPS_OpMod32_0(v) case OpMod32u: - return rewriteValueMIPS_OpMod32u(v) + return rewriteValueMIPS_OpMod32u_0(v) case OpMod8: - return rewriteValueMIPS_OpMod8(v) + return rewriteValueMIPS_OpMod8_0(v) case OpMod8u: - return rewriteValueMIPS_OpMod8u(v) + return rewriteValueMIPS_OpMod8u_0(v) case OpMove: - return rewriteValueMIPS_OpMove(v) + return rewriteValueMIPS_OpMove_0(v) || rewriteValueMIPS_OpMove_10(v) case OpMul16: - return rewriteValueMIPS_OpMul16(v) + return rewriteValueMIPS_OpMul16_0(v) case OpMul32: - return rewriteValueMIPS_OpMul32(v) + return rewriteValueMIPS_OpMul32_0(v) case OpMul32F: - return rewriteValueMIPS_OpMul32F(v) + return rewriteValueMIPS_OpMul32F_0(v) case OpMul32uhilo: - return rewriteValueMIPS_OpMul32uhilo(v) + return rewriteValueMIPS_OpMul32uhilo_0(v) case OpMul64F: - return rewriteValueMIPS_OpMul64F(v) + return rewriteValueMIPS_OpMul64F_0(v) case OpMul8: - return rewriteValueMIPS_OpMul8(v) + return rewriteValueMIPS_OpMul8_0(v) case OpNeg16: - return rewriteValueMIPS_OpNeg16(v) + return rewriteValueMIPS_OpNeg16_0(v) case OpNeg32: - return rewriteValueMIPS_OpNeg32(v) + return rewriteValueMIPS_OpNeg32_0(v) case OpNeg32F: - return rewriteValueMIPS_OpNeg32F(v) + return rewriteValueMIPS_OpNeg32F_0(v) case OpNeg64F: - return rewriteValueMIPS_OpNeg64F(v) + return rewriteValueMIPS_OpNeg64F_0(v) case OpNeg8: - return rewriteValueMIPS_OpNeg8(v) + return rewriteValueMIPS_OpNeg8_0(v) case OpNeq16: - return rewriteValueMIPS_OpNeq16(v) + return rewriteValueMIPS_OpNeq16_0(v) case OpNeq32: - return rewriteValueMIPS_OpNeq32(v) + return rewriteValueMIPS_OpNeq32_0(v) case OpNeq32F: - return rewriteValueMIPS_OpNeq32F(v) + return rewriteValueMIPS_OpNeq32F_0(v) case OpNeq64F: - return rewriteValueMIPS_OpNeq64F(v) + return rewriteValueMIPS_OpNeq64F_0(v) case OpNeq8: - return rewriteValueMIPS_OpNeq8(v) + return rewriteValueMIPS_OpNeq8_0(v) case OpNeqB: - return rewriteValueMIPS_OpNeqB(v) + return rewriteValueMIPS_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueMIPS_OpNeqPtr(v) + return rewriteValueMIPS_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueMIPS_OpNilCheck(v) + return rewriteValueMIPS_OpNilCheck_0(v) case OpNot: - return rewriteValueMIPS_OpNot(v) + return rewriteValueMIPS_OpNot_0(v) case OpOffPtr: - return rewriteValueMIPS_OpOffPtr(v) + return rewriteValueMIPS_OpOffPtr_0(v) case OpOr16: - return rewriteValueMIPS_OpOr16(v) + return rewriteValueMIPS_OpOr16_0(v) case OpOr32: - return rewriteValueMIPS_OpOr32(v) + return rewriteValueMIPS_OpOr32_0(v) case OpOr8: - return rewriteValueMIPS_OpOr8(v) + return rewriteValueMIPS_OpOr8_0(v) case OpOrB: - return rewriteValueMIPS_OpOrB(v) + return rewriteValueMIPS_OpOrB_0(v) case OpRound32F: - return rewriteValueMIPS_OpRound32F(v) + return rewriteValueMIPS_OpRound32F_0(v) case OpRound64F: - return rewriteValueMIPS_OpRound64F(v) + return rewriteValueMIPS_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueMIPS_OpRsh16Ux16(v) + return rewriteValueMIPS_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueMIPS_OpRsh16Ux32(v) + return rewriteValueMIPS_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueMIPS_OpRsh16Ux64(v) + return rewriteValueMIPS_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueMIPS_OpRsh16Ux8(v) + return rewriteValueMIPS_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueMIPS_OpRsh16x16(v) + return rewriteValueMIPS_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueMIPS_OpRsh16x32(v) + return rewriteValueMIPS_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueMIPS_OpRsh16x64(v) + return rewriteValueMIPS_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueMIPS_OpRsh16x8(v) + return rewriteValueMIPS_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueMIPS_OpRsh32Ux16(v) + return rewriteValueMIPS_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueMIPS_OpRsh32Ux32(v) + return rewriteValueMIPS_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueMIPS_OpRsh32Ux64(v) + return rewriteValueMIPS_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueMIPS_OpRsh32Ux8(v) + return rewriteValueMIPS_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueMIPS_OpRsh32x16(v) + return rewriteValueMIPS_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueMIPS_OpRsh32x32(v) + return rewriteValueMIPS_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueMIPS_OpRsh32x64(v) + return rewriteValueMIPS_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueMIPS_OpRsh32x8(v) + return rewriteValueMIPS_OpRsh32x8_0(v) case OpRsh8Ux16: - return rewriteValueMIPS_OpRsh8Ux16(v) + return rewriteValueMIPS_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueMIPS_OpRsh8Ux32(v) + return rewriteValueMIPS_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueMIPS_OpRsh8Ux64(v) + return rewriteValueMIPS_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueMIPS_OpRsh8Ux8(v) + return rewriteValueMIPS_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueMIPS_OpRsh8x16(v) + return rewriteValueMIPS_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueMIPS_OpRsh8x32(v) + return rewriteValueMIPS_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueMIPS_OpRsh8x64(v) + return rewriteValueMIPS_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueMIPS_OpRsh8x8(v) + return rewriteValueMIPS_OpRsh8x8_0(v) case OpSelect0: - return rewriteValueMIPS_OpSelect0(v) + return rewriteValueMIPS_OpSelect0_0(v) || rewriteValueMIPS_OpSelect0_10(v) case OpSelect1: - return rewriteValueMIPS_OpSelect1(v) + return rewriteValueMIPS_OpSelect1_0(v) || rewriteValueMIPS_OpSelect1_10(v) case OpSignExt16to32: - return rewriteValueMIPS_OpSignExt16to32(v) + return rewriteValueMIPS_OpSignExt16to32_0(v) case OpSignExt8to16: - return rewriteValueMIPS_OpSignExt8to16(v) + return rewriteValueMIPS_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueMIPS_OpSignExt8to32(v) + return rewriteValueMIPS_OpSignExt8to32_0(v) case OpSignmask: - return rewriteValueMIPS_OpSignmask(v) + return rewriteValueMIPS_OpSignmask_0(v) case OpSlicemask: - return rewriteValueMIPS_OpSlicemask(v) + return rewriteValueMIPS_OpSlicemask_0(v) case OpSqrt: - return rewriteValueMIPS_OpSqrt(v) + return rewriteValueMIPS_OpSqrt_0(v) case OpStaticCall: - return rewriteValueMIPS_OpStaticCall(v) + return rewriteValueMIPS_OpStaticCall_0(v) case OpStore: - return rewriteValueMIPS_OpStore(v) + return rewriteValueMIPS_OpStore_0(v) case OpSub16: - return rewriteValueMIPS_OpSub16(v) + return rewriteValueMIPS_OpSub16_0(v) case OpSub32: - return rewriteValueMIPS_OpSub32(v) + return rewriteValueMIPS_OpSub32_0(v) case OpSub32F: - return rewriteValueMIPS_OpSub32F(v) + return rewriteValueMIPS_OpSub32F_0(v) case OpSub32withcarry: - return rewriteValueMIPS_OpSub32withcarry(v) + return rewriteValueMIPS_OpSub32withcarry_0(v) case OpSub64F: - return rewriteValueMIPS_OpSub64F(v) + return rewriteValueMIPS_OpSub64F_0(v) case OpSub8: - return rewriteValueMIPS_OpSub8(v) + return rewriteValueMIPS_OpSub8_0(v) case OpSubPtr: - return rewriteValueMIPS_OpSubPtr(v) + return rewriteValueMIPS_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueMIPS_OpTrunc16to8(v) + return rewriteValueMIPS_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueMIPS_OpTrunc32to16(v) + return rewriteValueMIPS_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueMIPS_OpTrunc32to8(v) + return rewriteValueMIPS_OpTrunc32to8_0(v) case OpXor16: - return rewriteValueMIPS_OpXor16(v) + return rewriteValueMIPS_OpXor16_0(v) case OpXor32: - return rewriteValueMIPS_OpXor32(v) + return rewriteValueMIPS_OpXor32_0(v) case OpXor8: - return rewriteValueMIPS_OpXor8(v) + return rewriteValueMIPS_OpXor8_0(v) case OpZero: - return rewriteValueMIPS_OpZero(v) + return rewriteValueMIPS_OpZero_0(v) || rewriteValueMIPS_OpZero_10(v) case OpZeroExt16to32: - return rewriteValueMIPS_OpZeroExt16to32(v) + return rewriteValueMIPS_OpZeroExt16to32_0(v) case OpZeroExt8to16: - return rewriteValueMIPS_OpZeroExt8to16(v) + return rewriteValueMIPS_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueMIPS_OpZeroExt8to32(v) + return rewriteValueMIPS_OpZeroExt8to32_0(v) case OpZeromask: - return rewriteValueMIPS_OpZeromask(v) + return rewriteValueMIPS_OpZeromask_0(v) } return false } -func rewriteValueMIPS_OpAdd16(v *Value) bool { +func rewriteValueMIPS_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -519,7 +519,7 @@ func rewriteValueMIPS_OpAdd16(v *Value) bool { return true } } -func rewriteValueMIPS_OpAdd32(v *Value) bool { +func rewriteValueMIPS_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -532,7 +532,7 @@ func rewriteValueMIPS_OpAdd32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAdd32F(v *Value) bool { +func rewriteValueMIPS_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -545,7 +545,7 @@ func rewriteValueMIPS_OpAdd32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool { +func rewriteValueMIPS_OpAdd32withcarry_0(v *Value) bool { b := v.Block _ = b // match: (Add32withcarry x y c) @@ -565,7 +565,7 @@ func rewriteValueMIPS_OpAdd32withcarry(v *Value) bool { return true } } -func rewriteValueMIPS_OpAdd64F(v *Value) bool { +func rewriteValueMIPS_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -578,7 +578,7 @@ func rewriteValueMIPS_OpAdd64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpAdd8(v *Value) bool { +func rewriteValueMIPS_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -591,7 +591,7 @@ func rewriteValueMIPS_OpAdd8(v *Value) bool { return true } } -func rewriteValueMIPS_OpAddPtr(v *Value) bool { +func rewriteValueMIPS_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -604,7 +604,7 @@ func rewriteValueMIPS_OpAddPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpAddr(v *Value) bool { +func rewriteValueMIPS_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVWaddr {sym} base) @@ -617,7 +617,7 @@ func rewriteValueMIPS_OpAddr(v *Value) bool { return true } } -func rewriteValueMIPS_OpAnd16(v *Value) bool { +func rewriteValueMIPS_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -630,7 +630,7 @@ func rewriteValueMIPS_OpAnd16(v *Value) bool { return true } } -func rewriteValueMIPS_OpAnd32(v *Value) bool { +func rewriteValueMIPS_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -643,7 +643,7 @@ func rewriteValueMIPS_OpAnd32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAnd8(v *Value) bool { +func rewriteValueMIPS_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -656,7 +656,7 @@ func rewriteValueMIPS_OpAnd8(v *Value) bool { return true } } -func rewriteValueMIPS_OpAndB(v *Value) bool { +func rewriteValueMIPS_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -669,7 +669,7 @@ func rewriteValueMIPS_OpAndB(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool { +func rewriteValueMIPS_OpAtomicAdd32_0(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd ptr val mem) @@ -684,7 +684,7 @@ func rewriteValueMIPS_OpAtomicAdd32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool { +func rewriteValueMIPS_OpAtomicAnd8_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -797,7 +797,7 @@ func rewriteValueMIPS_OpAtomicAnd8(v *Value) bool { } return false } -func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool { +func rewriteValueMIPS_OpAtomicCompareAndSwap32_0(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas ptr old new_ mem) @@ -814,7 +814,7 @@ func rewriteValueMIPS_OpAtomicCompareAndSwap32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool { +func rewriteValueMIPS_OpAtomicExchange32_0(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange ptr val mem) @@ -829,7 +829,7 @@ func rewriteValueMIPS_OpAtomicExchange32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool { +func rewriteValueMIPS_OpAtomicLoad32_0(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LoweredAtomicLoad ptr mem) @@ -842,7 +842,7 @@ func rewriteValueMIPS_OpAtomicLoad32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool { +func rewriteValueMIPS_OpAtomicLoadPtr_0(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LoweredAtomicLoad ptr mem) @@ -855,7 +855,7 @@ func rewriteValueMIPS_OpAtomicLoadPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicOr8(v *Value) bool { +func rewriteValueMIPS_OpAtomicOr8_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -931,7 +931,7 @@ func rewriteValueMIPS_OpAtomicOr8(v *Value) bool { } return false } -func rewriteValueMIPS_OpAtomicStore32(v *Value) bool { +func rewriteValueMIPS_OpAtomicStore32_0(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (LoweredAtomicStore ptr val mem) @@ -946,7 +946,7 @@ func rewriteValueMIPS_OpAtomicStore32(v *Value) bool { return true } } -func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool { +func rewriteValueMIPS_OpAtomicStorePtrNoWB_0(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (LoweredAtomicStore ptr val mem) @@ -961,7 +961,7 @@ func rewriteValueMIPS_OpAtomicStorePtrNoWB(v *Value) bool { return true } } -func rewriteValueMIPS_OpAvg32u(v *Value) bool { +func rewriteValueMIPS_OpAvg32u_0(v *Value) bool { b := v.Block _ = b // match: (Avg32u x y) @@ -983,7 +983,7 @@ func rewriteValueMIPS_OpAvg32u(v *Value) bool { return true } } -func rewriteValueMIPS_OpBitLen32(v *Value) bool { +func rewriteValueMIPS_OpBitLen32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1004,7 +1004,7 @@ func rewriteValueMIPS_OpBitLen32(v *Value) bool { return true } } -func rewriteValueMIPS_OpClosureCall(v *Value) bool { +func rewriteValueMIPS_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1021,7 +1021,7 @@ func rewriteValueMIPS_OpClosureCall(v *Value) bool { return true } } -func rewriteValueMIPS_OpCom16(v *Value) bool { +func rewriteValueMIPS_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (NORconst [0] x) @@ -1033,7 +1033,7 @@ func rewriteValueMIPS_OpCom16(v *Value) bool { return true } } -func rewriteValueMIPS_OpCom32(v *Value) bool { +func rewriteValueMIPS_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (NORconst [0] x) @@ -1045,7 +1045,7 @@ func rewriteValueMIPS_OpCom32(v *Value) bool { return true } } -func rewriteValueMIPS_OpCom8(v *Value) bool { +func rewriteValueMIPS_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (NORconst [0] x) @@ -1057,7 +1057,7 @@ func rewriteValueMIPS_OpCom8(v *Value) bool { return true } } -func rewriteValueMIPS_OpConst16(v *Value) bool { +func rewriteValueMIPS_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVWconst [val]) @@ -1068,7 +1068,7 @@ func rewriteValueMIPS_OpConst16(v *Value) bool { return true } } -func rewriteValueMIPS_OpConst32(v *Value) bool { +func rewriteValueMIPS_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVWconst [val]) @@ -1079,7 +1079,7 @@ func rewriteValueMIPS_OpConst32(v *Value) bool { return true } } -func rewriteValueMIPS_OpConst32F(v *Value) bool { +func rewriteValueMIPS_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -1090,7 +1090,7 @@ func rewriteValueMIPS_OpConst32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpConst64F(v *Value) bool { +func rewriteValueMIPS_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -1101,7 +1101,7 @@ func rewriteValueMIPS_OpConst64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpConst8(v *Value) bool { +func rewriteValueMIPS_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVWconst [val]) @@ -1112,7 +1112,7 @@ func rewriteValueMIPS_OpConst8(v *Value) bool { return true } } -func rewriteValueMIPS_OpConstBool(v *Value) bool { +func rewriteValueMIPS_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVWconst [b]) @@ -1123,7 +1123,7 @@ func rewriteValueMIPS_OpConstBool(v *Value) bool { return true } } -func rewriteValueMIPS_OpConstNil(v *Value) bool { +func rewriteValueMIPS_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVWconst [0]) @@ -1133,7 +1133,7 @@ func rewriteValueMIPS_OpConstNil(v *Value) bool { return true } } -func rewriteValueMIPS_OpConvert(v *Value) bool { +func rewriteValueMIPS_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVWconvert x mem) @@ -1146,7 +1146,7 @@ func rewriteValueMIPS_OpConvert(v *Value) bool { return true } } -func rewriteValueMIPS_OpCtz32(v *Value) bool { +func rewriteValueMIPS_OpCtz32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1175,7 +1175,7 @@ func rewriteValueMIPS_OpCtz32(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool { +func rewriteValueMIPS_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (TRUNCFW x) @@ -1186,7 +1186,7 @@ func rewriteValueMIPS_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool { +func rewriteValueMIPS_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -1197,7 +1197,7 @@ func rewriteValueMIPS_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt32to32F(v *Value) bool { +func rewriteValueMIPS_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -1208,7 +1208,7 @@ func rewriteValueMIPS_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt32to64F(v *Value) bool { +func rewriteValueMIPS_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -1219,7 +1219,7 @@ func rewriteValueMIPS_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool { +func rewriteValueMIPS_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (TRUNCDW x) @@ -1230,7 +1230,7 @@ func rewriteValueMIPS_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool { +func rewriteValueMIPS_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -1241,7 +1241,7 @@ func rewriteValueMIPS_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv16(v *Value) bool { +func rewriteValueMIPS_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1264,7 +1264,7 @@ func rewriteValueMIPS_OpDiv16(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv16u(v *Value) bool { +func rewriteValueMIPS_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1287,7 +1287,7 @@ func rewriteValueMIPS_OpDiv16u(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv32(v *Value) bool { +func rewriteValueMIPS_OpDiv32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1306,7 +1306,7 @@ func rewriteValueMIPS_OpDiv32(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv32F(v *Value) bool { +func rewriteValueMIPS_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -1319,7 +1319,7 @@ func rewriteValueMIPS_OpDiv32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv32u(v *Value) bool { +func rewriteValueMIPS_OpDiv32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1338,7 +1338,7 @@ func rewriteValueMIPS_OpDiv32u(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv64F(v *Value) bool { +func rewriteValueMIPS_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -1351,7 +1351,7 @@ func rewriteValueMIPS_OpDiv64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv8(v *Value) bool { +func rewriteValueMIPS_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1374,7 +1374,7 @@ func rewriteValueMIPS_OpDiv8(v *Value) bool { return true } } -func rewriteValueMIPS_OpDiv8u(v *Value) bool { +func rewriteValueMIPS_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1397,7 +1397,7 @@ func rewriteValueMIPS_OpDiv8u(v *Value) bool { return true } } -func rewriteValueMIPS_OpEq16(v *Value) bool { +func rewriteValueMIPS_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1421,7 +1421,7 @@ func rewriteValueMIPS_OpEq16(v *Value) bool { return true } } -func rewriteValueMIPS_OpEq32(v *Value) bool { +func rewriteValueMIPS_OpEq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1441,7 +1441,7 @@ func rewriteValueMIPS_OpEq32(v *Value) bool { return true } } -func rewriteValueMIPS_OpEq32F(v *Value) bool { +func rewriteValueMIPS_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1458,7 +1458,7 @@ func rewriteValueMIPS_OpEq32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpEq64F(v *Value) bool { +func rewriteValueMIPS_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1475,7 +1475,7 @@ func rewriteValueMIPS_OpEq64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpEq8(v *Value) bool { +func rewriteValueMIPS_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1499,7 +1499,7 @@ func rewriteValueMIPS_OpEq8(v *Value) bool { return true } } -func rewriteValueMIPS_OpEqB(v *Value) bool { +func rewriteValueMIPS_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1519,7 +1519,7 @@ func rewriteValueMIPS_OpEqB(v *Value) bool { return true } } -func rewriteValueMIPS_OpEqPtr(v *Value) bool { +func rewriteValueMIPS_OpEqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1539,7 +1539,7 @@ func rewriteValueMIPS_OpEqPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq16(v *Value) bool { +func rewriteValueMIPS_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1563,7 +1563,7 @@ func rewriteValueMIPS_OpGeq16(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq16U(v *Value) bool { +func rewriteValueMIPS_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1587,7 +1587,7 @@ func rewriteValueMIPS_OpGeq16U(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq32(v *Value) bool { +func rewriteValueMIPS_OpGeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1607,7 +1607,7 @@ func rewriteValueMIPS_OpGeq32(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq32F(v *Value) bool { +func rewriteValueMIPS_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1624,7 +1624,7 @@ func rewriteValueMIPS_OpGeq32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq32U(v *Value) bool { +func rewriteValueMIPS_OpGeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1644,7 +1644,7 @@ func rewriteValueMIPS_OpGeq32U(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq64F(v *Value) bool { +func rewriteValueMIPS_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1661,7 +1661,7 @@ func rewriteValueMIPS_OpGeq64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq8(v *Value) bool { +func rewriteValueMIPS_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1685,7 +1685,7 @@ func rewriteValueMIPS_OpGeq8(v *Value) bool { return true } } -func rewriteValueMIPS_OpGeq8U(v *Value) bool { +func rewriteValueMIPS_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1709,7 +1709,7 @@ func rewriteValueMIPS_OpGeq8U(v *Value) bool { return true } } -func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool { +func rewriteValueMIPS_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1718,7 +1718,7 @@ func rewriteValueMIPS_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater16(v *Value) bool { +func rewriteValueMIPS_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1739,7 +1739,7 @@ func rewriteValueMIPS_OpGreater16(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater16U(v *Value) bool { +func rewriteValueMIPS_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1760,7 +1760,7 @@ func rewriteValueMIPS_OpGreater16U(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater32(v *Value) bool { +func rewriteValueMIPS_OpGreater32_0(v *Value) bool { // match: (Greater32 x y) // cond: // result: (SGT x y) @@ -1773,7 +1773,7 @@ func rewriteValueMIPS_OpGreater32(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater32F(v *Value) bool { +func rewriteValueMIPS_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1790,7 +1790,7 @@ func rewriteValueMIPS_OpGreater32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater32U(v *Value) bool { +func rewriteValueMIPS_OpGreater32U_0(v *Value) bool { // match: (Greater32U x y) // cond: // result: (SGTU x y) @@ -1803,7 +1803,7 @@ func rewriteValueMIPS_OpGreater32U(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater64F(v *Value) bool { +func rewriteValueMIPS_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -1820,7 +1820,7 @@ func rewriteValueMIPS_OpGreater64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater8(v *Value) bool { +func rewriteValueMIPS_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1841,7 +1841,7 @@ func rewriteValueMIPS_OpGreater8(v *Value) bool { return true } } -func rewriteValueMIPS_OpGreater8U(v *Value) bool { +func rewriteValueMIPS_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1862,7 +1862,7 @@ func rewriteValueMIPS_OpGreater8U(v *Value) bool { return true } } -func rewriteValueMIPS_OpHmul32(v *Value) bool { +func rewriteValueMIPS_OpHmul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1881,7 +1881,7 @@ func rewriteValueMIPS_OpHmul32(v *Value) bool { return true } } -func rewriteValueMIPS_OpHmul32u(v *Value) bool { +func rewriteValueMIPS_OpHmul32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1900,7 +1900,7 @@ func rewriteValueMIPS_OpHmul32u(v *Value) bool { return true } } -func rewriteValueMIPS_OpInterCall(v *Value) bool { +func rewriteValueMIPS_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -1915,7 +1915,7 @@ func rewriteValueMIPS_OpInterCall(v *Value) bool { return true } } -func rewriteValueMIPS_OpIsInBounds(v *Value) bool { +func rewriteValueMIPS_OpIsInBounds_0(v *Value) bool { // match: (IsInBounds idx len) // cond: // result: (SGTU len idx) @@ -1928,7 +1928,7 @@ func rewriteValueMIPS_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueMIPS_OpIsNonNil(v *Value) bool { +func rewriteValueMIPS_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1946,7 +1946,7 @@ func rewriteValueMIPS_OpIsNonNil(v *Value) bool { return true } } -func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool { +func rewriteValueMIPS_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1966,7 +1966,7 @@ func rewriteValueMIPS_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq16(v *Value) bool { +func rewriteValueMIPS_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1990,7 +1990,7 @@ func rewriteValueMIPS_OpLeq16(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq16U(v *Value) bool { +func rewriteValueMIPS_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2014,7 +2014,7 @@ func rewriteValueMIPS_OpLeq16U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq32(v *Value) bool { +func rewriteValueMIPS_OpLeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2034,7 +2034,7 @@ func rewriteValueMIPS_OpLeq32(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq32F(v *Value) bool { +func rewriteValueMIPS_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2051,7 +2051,7 @@ func rewriteValueMIPS_OpLeq32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq32U(v *Value) bool { +func rewriteValueMIPS_OpLeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2071,7 +2071,7 @@ func rewriteValueMIPS_OpLeq32U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq64F(v *Value) bool { +func rewriteValueMIPS_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2088,7 +2088,7 @@ func rewriteValueMIPS_OpLeq64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq8(v *Value) bool { +func rewriteValueMIPS_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2112,7 +2112,7 @@ func rewriteValueMIPS_OpLeq8(v *Value) bool { return true } } -func rewriteValueMIPS_OpLeq8U(v *Value) bool { +func rewriteValueMIPS_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2136,7 +2136,7 @@ func rewriteValueMIPS_OpLeq8U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess16(v *Value) bool { +func rewriteValueMIPS_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2157,7 +2157,7 @@ func rewriteValueMIPS_OpLess16(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess16U(v *Value) bool { +func rewriteValueMIPS_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2178,7 +2178,7 @@ func rewriteValueMIPS_OpLess16U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess32(v *Value) bool { +func rewriteValueMIPS_OpLess32_0(v *Value) bool { // match: (Less32 x y) // cond: // result: (SGT y x) @@ -2191,7 +2191,7 @@ func rewriteValueMIPS_OpLess32(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess32F(v *Value) bool { +func rewriteValueMIPS_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2208,7 +2208,7 @@ func rewriteValueMIPS_OpLess32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess32U(v *Value) bool { +func rewriteValueMIPS_OpLess32U_0(v *Value) bool { // match: (Less32U x y) // cond: // result: (SGTU y x) @@ -2221,7 +2221,7 @@ func rewriteValueMIPS_OpLess32U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess64F(v *Value) bool { +func rewriteValueMIPS_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2238,7 +2238,7 @@ func rewriteValueMIPS_OpLess64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess8(v *Value) bool { +func rewriteValueMIPS_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2259,7 +2259,7 @@ func rewriteValueMIPS_OpLess8(v *Value) bool { return true } } -func rewriteValueMIPS_OpLess8U(v *Value) bool { +func rewriteValueMIPS_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2280,7 +2280,7 @@ func rewriteValueMIPS_OpLess8U(v *Value) bool { return true } } -func rewriteValueMIPS_OpLoad(v *Value) bool { +func rewriteValueMIPS_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -2403,7 +2403,7 @@ func rewriteValueMIPS_OpLoad(v *Value) bool { } return false } -func rewriteValueMIPS_OpLsh16x16(v *Value) bool { +func rewriteValueMIPS_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2434,7 +2434,7 @@ func rewriteValueMIPS_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh16x32(v *Value) bool { +func rewriteValueMIPS_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2461,7 +2461,7 @@ func rewriteValueMIPS_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh16x64(v *Value) bool { +func rewriteValueMIPS_OpLsh16x64_0(v *Value) bool { // match: (Lsh16x64 x (Const64 [c])) // cond: uint32(c) < 16 // result: (SLLconst x [c]) @@ -2498,7 +2498,7 @@ func rewriteValueMIPS_OpLsh16x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpLsh16x8(v *Value) bool { +func rewriteValueMIPS_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2529,7 +2529,7 @@ func rewriteValueMIPS_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh32x16(v *Value) bool { +func rewriteValueMIPS_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2560,7 +2560,7 @@ func rewriteValueMIPS_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh32x32(v *Value) bool { +func rewriteValueMIPS_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2587,7 +2587,7 @@ func rewriteValueMIPS_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh32x64(v *Value) bool { +func rewriteValueMIPS_OpLsh32x64_0(v *Value) bool { // match: (Lsh32x64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SLLconst x [c]) @@ -2624,7 +2624,7 @@ func rewriteValueMIPS_OpLsh32x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpLsh32x8(v *Value) bool { +func rewriteValueMIPS_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2655,7 +2655,7 @@ func rewriteValueMIPS_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh8x16(v *Value) bool { +func rewriteValueMIPS_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2686,7 +2686,7 @@ func rewriteValueMIPS_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh8x32(v *Value) bool { +func rewriteValueMIPS_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2713,7 +2713,7 @@ func rewriteValueMIPS_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpLsh8x64(v *Value) bool { +func rewriteValueMIPS_OpLsh8x64_0(v *Value) bool { // match: (Lsh8x64 x (Const64 [c])) // cond: uint32(c) < 8 // result: (SLLconst x [c]) @@ -2750,7 +2750,7 @@ func rewriteValueMIPS_OpLsh8x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpLsh8x8(v *Value) bool { +func rewriteValueMIPS_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2781,7 +2781,7 @@ func rewriteValueMIPS_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpMIPSADD(v *Value) bool { +func rewriteValueMIPS_OpMIPSADD_0(v *Value) bool { // match: (ADD x (MOVWconst [c])) // cond: // result: (ADDconst [c] x) @@ -2844,7 +2844,7 @@ func rewriteValueMIPS_OpMIPSADD(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSADDconst_0(v *Value) bool { // match: (ADDconst [off1] (MOVWaddr [off2] {sym} ptr)) // cond: // result: (MOVWaddr [off1+off2] {sym} ptr) @@ -2924,7 +2924,7 @@ func rewriteValueMIPS_OpMIPSADDconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSAND(v *Value) bool { +func rewriteValueMIPS_OpMIPSAND_0(v *Value) bool { b := v.Block _ = b // match: (AND x (MOVWconst [c])) @@ -3028,7 +3028,7 @@ func rewriteValueMIPS_OpMIPSAND(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSANDconst_0(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVWconst [0]) @@ -3085,7 +3085,7 @@ func rewriteValueMIPS_OpMIPSANDconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool { +func rewriteValueMIPS_OpMIPSCMOVZ_0(v *Value) bool { b := v.Block _ = b // match: (CMOVZ _ b (MOVWconst [0])) @@ -3143,7 +3143,7 @@ func rewriteValueMIPS_OpMIPSCMOVZ(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool { +func rewriteValueMIPS_OpMIPSCMOVZzero_0(v *Value) bool { // match: (CMOVZzero _ (MOVWconst [0])) // cond: // result: (MOVWconst [0]) @@ -3179,7 +3179,7 @@ func rewriteValueMIPS_OpMIPSCMOVZzero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool { +func rewriteValueMIPS_OpMIPSLoweredAtomicAdd_0(v *Value) bool { // match: (LoweredAtomicAdd ptr (MOVWconst [c]) mem) // cond: is16Bit(c) // result: (LoweredAtomicAddconst [c] ptr mem) @@ -3202,7 +3202,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicAdd(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool { +func rewriteValueMIPS_OpMIPSLoweredAtomicStore_0(v *Value) bool { // match: (LoweredAtomicStore ptr (MOVWconst [0]) mem) // cond: // result: (LoweredAtomicStorezero ptr mem) @@ -3223,7 +3223,7 @@ func rewriteValueMIPS_OpMIPSLoweredAtomicStore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBUload_0(v *Value) bool { // match: (MOVBUload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3296,7 +3296,7 @@ func rewriteValueMIPS_OpMIPSMOVBUload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBUreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVBUreg x:(MOVBUload _ _)) @@ -3379,7 +3379,7 @@ func rewriteValueMIPS_OpMIPSMOVBUreg(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBload_0(v *Value) bool { // match: (MOVBload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3452,7 +3452,7 @@ func rewriteValueMIPS_OpMIPSMOVBload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVBreg x:(MOVBload _ _)) @@ -3538,7 +3538,7 @@ func rewriteValueMIPS_OpMIPSMOVBreg(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBstore_0(v *Value) bool { // match: (MOVBstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -3719,7 +3719,7 @@ func rewriteValueMIPS_OpMIPSMOVBstore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVBstorezero_0(v *Value) bool { // match: (MOVBstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -3769,7 +3769,7 @@ func rewriteValueMIPS_OpMIPSMOVBstorezero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVDload_0(v *Value) bool { // match: (MOVDload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -3842,7 +3842,7 @@ func rewriteValueMIPS_OpMIPSMOVDload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -3896,7 +3896,7 @@ func rewriteValueMIPS_OpMIPSMOVDstore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVFload_0(v *Value) bool { // match: (MOVFload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -3969,7 +3969,7 @@ func rewriteValueMIPS_OpMIPSMOVFload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVFstore_0(v *Value) bool { // match: (MOVFstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -4023,7 +4023,7 @@ func rewriteValueMIPS_OpMIPSMOVFstore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHUload_0(v *Value) bool { // match: (MOVHUload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4096,7 +4096,7 @@ func rewriteValueMIPS_OpMIPSMOVHUload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHUreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVHUreg x:(MOVBUload _ _)) @@ -4203,7 +4203,7 @@ func rewriteValueMIPS_OpMIPSMOVHUreg(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4276,7 +4276,7 @@ func rewriteValueMIPS_OpMIPSMOVHload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVHreg x:(MOVBload _ _)) @@ -4410,7 +4410,7 @@ func rewriteValueMIPS_OpMIPSMOVHreg(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHstore_0(v *Value) bool { // match: (MOVHstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4549,7 +4549,7 @@ func rewriteValueMIPS_OpMIPSMOVHstore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVHstorezero_0(v *Value) bool { // match: (MOVHstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4599,7 +4599,7 @@ func rewriteValueMIPS_OpMIPSMOVHstorezero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVWload_0(v *Value) bool { // match: (MOVWload [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -4672,7 +4672,7 @@ func rewriteValueMIPS_OpMIPSMOVWload(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVWreg_0(v *Value) bool { // match: (MOVWreg x) // cond: x.Uses == 1 // result: (MOVWnop x) @@ -4700,7 +4700,7 @@ func rewriteValueMIPS_OpMIPSMOVWreg(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVWstore_0(v *Value) bool { // match: (MOVWstore [off1] {sym} x:(ADDconst [off2] ptr) val mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -4797,7 +4797,7 @@ func rewriteValueMIPS_OpMIPSMOVWstore(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool { +func rewriteValueMIPS_OpMIPSMOVWstorezero_0(v *Value) bool { // match: (MOVWstorezero [off1] {sym} x:(ADDconst [off2] ptr) mem) // cond: (is16Bit(off1+off2) || x.Uses == 1) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -4847,7 +4847,7 @@ func rewriteValueMIPS_OpMIPSMOVWstorezero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSMUL(v *Value) bool { +func rewriteValueMIPS_OpMIPSMUL_0(v *Value) bool { // match: (MUL (MOVWconst [0]) _) // cond: // result: (MOVWconst [0]) @@ -5018,7 +5018,7 @@ func rewriteValueMIPS_OpMIPSMUL(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSNEG(v *Value) bool { +func rewriteValueMIPS_OpMIPSNEG_0(v *Value) bool { // match: (NEG (MOVWconst [c])) // cond: // result: (MOVWconst [int64(int32(-c))]) @@ -5034,7 +5034,7 @@ func rewriteValueMIPS_OpMIPSNEG(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSNOR(v *Value) bool { +func rewriteValueMIPS_OpMIPSNOR_0(v *Value) bool { // match: (NOR x (MOVWconst [c])) // cond: // result: (NORconst [c] x) @@ -5067,7 +5067,7 @@ func rewriteValueMIPS_OpMIPSNOR(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSNORconst_0(v *Value) bool { // match: (NORconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [^(c|d)]) @@ -5084,7 +5084,7 @@ func rewriteValueMIPS_OpMIPSNORconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSOR(v *Value) bool { +func rewriteValueMIPS_OpMIPSOR_0(v *Value) bool { b := v.Block _ = b // match: (OR x (MOVWconst [c])) @@ -5174,7 +5174,7 @@ func rewriteValueMIPS_OpMIPSOR(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSORconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSORconst_0(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -5231,7 +5231,7 @@ func rewriteValueMIPS_OpMIPSORconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGT(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGT_0(v *Value) bool { // match: (SGT (MOVWconst [c]) x) // cond: // result: (SGTconst [c] x) @@ -5265,7 +5265,7 @@ func rewriteValueMIPS_OpMIPSSGT(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGTU_0(v *Value) bool { // match: (SGTU (MOVWconst [c]) x) // cond: // result: (SGTUconst [c] x) @@ -5299,7 +5299,7 @@ func rewriteValueMIPS_OpMIPSSGTU(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGTUconst_0(v *Value) bool { // match: (SGTUconst [c] (MOVWconst [d])) // cond: uint32(c)>uint32(d) // result: (MOVWconst [1]) @@ -5402,7 +5402,7 @@ func rewriteValueMIPS_OpMIPSSGTUconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGTUzero_0(v *Value) bool { // match: (SGTUzero (MOVWconst [d])) // cond: uint32(d) != 0 // result: (MOVWconst [1]) @@ -5437,7 +5437,7 @@ func rewriteValueMIPS_OpMIPSSGTUzero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGTconst_0(v *Value) bool { // match: (SGTconst [c] (MOVWconst [d])) // cond: int32(c) > int32(d) // result: (MOVWconst [1]) @@ -5600,6 +5600,9 @@ func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool { v.AuxInt = 0 return true } + return false +} +func rewriteValueMIPS_OpMIPSSGTconst_10(v *Value) bool { // match: (SGTconst [c] (ANDconst [m] _)) // cond: 0 <= int32(m) && int32(m) < int32(c) // result: (MOVWconst [1]) @@ -5636,7 +5639,7 @@ func rewriteValueMIPS_OpMIPSSGTconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool { +func rewriteValueMIPS_OpMIPSSGTzero_0(v *Value) bool { // match: (SGTzero (MOVWconst [d])) // cond: int32(d) > 0 // result: (MOVWconst [1]) @@ -5671,7 +5674,7 @@ func rewriteValueMIPS_OpMIPSSGTzero(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSLL(v *Value) bool { +func rewriteValueMIPS_OpMIPSSLL_0(v *Value) bool { // match: (SLL _ (MOVWconst [c])) // cond: uint32(c)>=32 // result: (MOVWconst [0]) @@ -5705,7 +5708,7 @@ func rewriteValueMIPS_OpMIPSSLL(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSLLconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSLLconst_0(v *Value) bool { // match: (SLLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(uint32(d)<=32 // result: (SRAconst x [31]) @@ -5758,7 +5761,7 @@ func rewriteValueMIPS_OpMIPSSRA(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSRAconst_0(v *Value) bool { // match: (SRAconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(int32(d)>>uint32(c))]) @@ -5775,7 +5778,7 @@ func rewriteValueMIPS_OpMIPSSRAconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSRL(v *Value) bool { +func rewriteValueMIPS_OpMIPSSRL_0(v *Value) bool { // match: (SRL _ (MOVWconst [c])) // cond: uint32(c)>=32 // result: (MOVWconst [0]) @@ -5809,7 +5812,7 @@ func rewriteValueMIPS_OpMIPSSRL(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSRLconst_0(v *Value) bool { // match: (SRLconst [c] (MOVWconst [d])) // cond: // result: (MOVWconst [int64(uint32(d)>>uint32(c))]) @@ -5826,7 +5829,7 @@ func rewriteValueMIPS_OpMIPSSRLconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSUB(v *Value) bool { +func rewriteValueMIPS_OpMIPSSUB_0(v *Value) bool { // match: (SUB x (MOVWconst [c])) // cond: // result: (SUBconst [c] x) @@ -5872,7 +5875,7 @@ func rewriteValueMIPS_OpMIPSSUB(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSSUBconst_0(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -5934,7 +5937,7 @@ func rewriteValueMIPS_OpMIPSSUBconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSXOR(v *Value) bool { +func rewriteValueMIPS_OpMIPSXOR_0(v *Value) bool { // match: (XOR x (MOVWconst [c])) // cond: // result: (XORconst [c] x) @@ -5979,7 +5982,7 @@ func rewriteValueMIPS_OpMIPSXOR(v *Value) bool { } return false } -func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool { +func rewriteValueMIPS_OpMIPSXORconst_0(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -6038,7 +6041,7 @@ func rewriteValueMIPS_OpMIPSXORconst(v *Value) bool { } return false } -func rewriteValueMIPS_OpMod16(v *Value) bool { +func rewriteValueMIPS_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6061,7 +6064,7 @@ func rewriteValueMIPS_OpMod16(v *Value) bool { return true } } -func rewriteValueMIPS_OpMod16u(v *Value) bool { +func rewriteValueMIPS_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6084,7 +6087,7 @@ func rewriteValueMIPS_OpMod16u(v *Value) bool { return true } } -func rewriteValueMIPS_OpMod32(v *Value) bool { +func rewriteValueMIPS_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6103,7 +6106,7 @@ func rewriteValueMIPS_OpMod32(v *Value) bool { return true } } -func rewriteValueMIPS_OpMod32u(v *Value) bool { +func rewriteValueMIPS_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6122,7 +6125,7 @@ func rewriteValueMIPS_OpMod32u(v *Value) bool { return true } } -func rewriteValueMIPS_OpMod8(v *Value) bool { +func rewriteValueMIPS_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6145,7 +6148,7 @@ func rewriteValueMIPS_OpMod8(v *Value) bool { return true } } -func rewriteValueMIPS_OpMod8u(v *Value) bool { +func rewriteValueMIPS_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6168,11 +6171,9 @@ func rewriteValueMIPS_OpMod8u(v *Value) bool { return true } } -func rewriteValueMIPS_OpMove(v *Value) bool { +func rewriteValueMIPS_OpMove_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Move [0] _ _ mem) @@ -6478,6 +6479,15 @@ func rewriteValueMIPS_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueMIPS_OpMove_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Move [6] {t} dst src mem) // cond: t.(Type).Alignment()%2 == 0 // result: (MOVHstore [4] dst (MOVHload [4] src mem) (MOVHstore [2] dst (MOVHload [2] src mem) (MOVHstore dst (MOVHload src mem) mem))) @@ -6635,7 +6645,7 @@ func rewriteValueMIPS_OpMove(v *Value) bool { } return false } -func rewriteValueMIPS_OpMul16(v *Value) bool { +func rewriteValueMIPS_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MUL x y) @@ -6648,7 +6658,7 @@ func rewriteValueMIPS_OpMul16(v *Value) bool { return true } } -func rewriteValueMIPS_OpMul32(v *Value) bool { +func rewriteValueMIPS_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MUL x y) @@ -6661,7 +6671,7 @@ func rewriteValueMIPS_OpMul32(v *Value) bool { return true } } -func rewriteValueMIPS_OpMul32F(v *Value) bool { +func rewriteValueMIPS_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -6674,7 +6684,7 @@ func rewriteValueMIPS_OpMul32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpMul32uhilo(v *Value) bool { +func rewriteValueMIPS_OpMul32uhilo_0(v *Value) bool { // match: (Mul32uhilo x y) // cond: // result: (MULTU x y) @@ -6687,7 +6697,7 @@ func rewriteValueMIPS_OpMul32uhilo(v *Value) bool { return true } } -func rewriteValueMIPS_OpMul64F(v *Value) bool { +func rewriteValueMIPS_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -6700,7 +6710,7 @@ func rewriteValueMIPS_OpMul64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpMul8(v *Value) bool { +func rewriteValueMIPS_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MUL x y) @@ -6713,7 +6723,7 @@ func rewriteValueMIPS_OpMul8(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeg16(v *Value) bool { +func rewriteValueMIPS_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -6724,7 +6734,7 @@ func rewriteValueMIPS_OpNeg16(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeg32(v *Value) bool { +func rewriteValueMIPS_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -6735,7 +6745,7 @@ func rewriteValueMIPS_OpNeg32(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeg32F(v *Value) bool { +func rewriteValueMIPS_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -6746,7 +6756,7 @@ func rewriteValueMIPS_OpNeg32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeg64F(v *Value) bool { +func rewriteValueMIPS_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -6757,7 +6767,7 @@ func rewriteValueMIPS_OpNeg64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeg8(v *Value) bool { +func rewriteValueMIPS_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -6768,7 +6778,7 @@ func rewriteValueMIPS_OpNeg8(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeq16(v *Value) bool { +func rewriteValueMIPS_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6794,7 +6804,7 @@ func rewriteValueMIPS_OpNeq16(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeq32(v *Value) bool { +func rewriteValueMIPS_OpNeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6816,7 +6826,7 @@ func rewriteValueMIPS_OpNeq32(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeq32F(v *Value) bool { +func rewriteValueMIPS_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -6833,7 +6843,7 @@ func rewriteValueMIPS_OpNeq32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeq64F(v *Value) bool { +func rewriteValueMIPS_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -6850,7 +6860,7 @@ func rewriteValueMIPS_OpNeq64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeq8(v *Value) bool { +func rewriteValueMIPS_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6876,7 +6886,7 @@ func rewriteValueMIPS_OpNeq8(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeqB(v *Value) bool { +func rewriteValueMIPS_OpNeqB_0(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -6889,7 +6899,7 @@ func rewriteValueMIPS_OpNeqB(v *Value) bool { return true } } -func rewriteValueMIPS_OpNeqPtr(v *Value) bool { +func rewriteValueMIPS_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6911,7 +6921,7 @@ func rewriteValueMIPS_OpNeqPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpNilCheck(v *Value) bool { +func rewriteValueMIPS_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -6924,7 +6934,7 @@ func rewriteValueMIPS_OpNilCheck(v *Value) bool { return true } } -func rewriteValueMIPS_OpNot(v *Value) bool { +func rewriteValueMIPS_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -6936,7 +6946,7 @@ func rewriteValueMIPS_OpNot(v *Value) bool { return true } } -func rewriteValueMIPS_OpOffPtr(v *Value) bool { +func rewriteValueMIPS_OpOffPtr_0(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVWaddr [off] ptr) @@ -6963,7 +6973,7 @@ func rewriteValueMIPS_OpOffPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpOr16(v *Value) bool { +func rewriteValueMIPS_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -6976,7 +6986,7 @@ func rewriteValueMIPS_OpOr16(v *Value) bool { return true } } -func rewriteValueMIPS_OpOr32(v *Value) bool { +func rewriteValueMIPS_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -6989,7 +6999,7 @@ func rewriteValueMIPS_OpOr32(v *Value) bool { return true } } -func rewriteValueMIPS_OpOr8(v *Value) bool { +func rewriteValueMIPS_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -7002,7 +7012,7 @@ func rewriteValueMIPS_OpOr8(v *Value) bool { return true } } -func rewriteValueMIPS_OpOrB(v *Value) bool { +func rewriteValueMIPS_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -7015,7 +7025,7 @@ func rewriteValueMIPS_OpOrB(v *Value) bool { return true } } -func rewriteValueMIPS_OpRound32F(v *Value) bool { +func rewriteValueMIPS_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -7027,7 +7037,7 @@ func rewriteValueMIPS_OpRound32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpRound64F(v *Value) bool { +func rewriteValueMIPS_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -7039,7 +7049,7 @@ func rewriteValueMIPS_OpRound64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool { +func rewriteValueMIPS_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7072,7 +7082,7 @@ func rewriteValueMIPS_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool { +func rewriteValueMIPS_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7101,7 +7111,7 @@ func rewriteValueMIPS_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool { +func rewriteValueMIPS_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7145,7 +7155,7 @@ func rewriteValueMIPS_OpRsh16Ux64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool { +func rewriteValueMIPS_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7178,7 +7188,7 @@ func rewriteValueMIPS_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16x16(v *Value) bool { +func rewriteValueMIPS_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7210,7 +7220,7 @@ func rewriteValueMIPS_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16x32(v *Value) bool { +func rewriteValueMIPS_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7238,7 +7248,7 @@ func rewriteValueMIPS_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh16x64(v *Value) bool { +func rewriteValueMIPS_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7287,7 +7297,7 @@ func rewriteValueMIPS_OpRsh16x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh16x8(v *Value) bool { +func rewriteValueMIPS_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7319,7 +7329,7 @@ func rewriteValueMIPS_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool { +func rewriteValueMIPS_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7350,7 +7360,7 @@ func rewriteValueMIPS_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool { +func rewriteValueMIPS_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7377,7 +7387,7 @@ func rewriteValueMIPS_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool { +func rewriteValueMIPS_OpRsh32Ux64_0(v *Value) bool { // match: (Rsh32Ux64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRLconst x [c]) @@ -7414,7 +7424,7 @@ func rewriteValueMIPS_OpRsh32Ux64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool { +func rewriteValueMIPS_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7445,7 +7455,7 @@ func rewriteValueMIPS_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32x16(v *Value) bool { +func rewriteValueMIPS_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7475,7 +7485,7 @@ func rewriteValueMIPS_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32x32(v *Value) bool { +func rewriteValueMIPS_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7501,7 +7511,7 @@ func rewriteValueMIPS_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh32x64(v *Value) bool { +func rewriteValueMIPS_OpRsh32x64_0(v *Value) bool { // match: (Rsh32x64 x (Const64 [c])) // cond: uint32(c) < 32 // result: (SRAconst x [c]) @@ -7540,7 +7550,7 @@ func rewriteValueMIPS_OpRsh32x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh32x8(v *Value) bool { +func rewriteValueMIPS_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7570,7 +7580,7 @@ func rewriteValueMIPS_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool { +func rewriteValueMIPS_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7603,7 +7613,7 @@ func rewriteValueMIPS_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool { +func rewriteValueMIPS_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7632,7 +7642,7 @@ func rewriteValueMIPS_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool { +func rewriteValueMIPS_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7676,7 +7686,7 @@ func rewriteValueMIPS_OpRsh8Ux64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool { +func rewriteValueMIPS_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7709,7 +7719,7 @@ func rewriteValueMIPS_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8x16(v *Value) bool { +func rewriteValueMIPS_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7741,7 +7751,7 @@ func rewriteValueMIPS_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8x32(v *Value) bool { +func rewriteValueMIPS_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7769,7 +7779,7 @@ func rewriteValueMIPS_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueMIPS_OpRsh8x64(v *Value) bool { +func rewriteValueMIPS_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7818,7 +7828,7 @@ func rewriteValueMIPS_OpRsh8x64(v *Value) bool { } return false } -func rewriteValueMIPS_OpRsh8x8(v *Value) bool { +func rewriteValueMIPS_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7850,7 +7860,7 @@ func rewriteValueMIPS_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueMIPS_OpSelect0(v *Value) bool { +func rewriteValueMIPS_OpSelect0_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8063,6 +8073,9 @@ func rewriteValueMIPS_OpSelect0(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueMIPS_OpSelect0_10(v *Value) bool { // match: (Select0 (MULTU (MOVWconst [c]) (MOVWconst [d]))) // cond: // result: (MOVWconst [(c*d)>>32]) @@ -8153,7 +8166,7 @@ func rewriteValueMIPS_OpSelect0(v *Value) bool { } return false } -func rewriteValueMIPS_OpSelect1(v *Value) bool { +func rewriteValueMIPS_OpSelect1_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8364,6 +8377,9 @@ func rewriteValueMIPS_OpSelect1(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueMIPS_OpSelect1_10(v *Value) bool { // match: (Select1 (MULTU (MOVWconst [c]) (MOVWconst [d]))) // cond: // result: (MOVWconst [int64(int32(uint32(c)*uint32(d)))]) @@ -8454,7 +8470,7 @@ func rewriteValueMIPS_OpSelect1(v *Value) bool { } return false } -func rewriteValueMIPS_OpSignExt16to32(v *Value) bool { +func rewriteValueMIPS_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -8465,7 +8481,7 @@ func rewriteValueMIPS_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueMIPS_OpSignExt8to16(v *Value) bool { +func rewriteValueMIPS_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -8476,7 +8492,7 @@ func rewriteValueMIPS_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueMIPS_OpSignExt8to32(v *Value) bool { +func rewriteValueMIPS_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -8487,7 +8503,7 @@ func rewriteValueMIPS_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueMIPS_OpSignmask(v *Value) bool { +func rewriteValueMIPS_OpSignmask_0(v *Value) bool { // match: (Signmask x) // cond: // result: (SRAconst x [31]) @@ -8499,7 +8515,7 @@ func rewriteValueMIPS_OpSignmask(v *Value) bool { return true } } -func rewriteValueMIPS_OpSlicemask(v *Value) bool { +func rewriteValueMIPS_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -8516,7 +8532,7 @@ func rewriteValueMIPS_OpSlicemask(v *Value) bool { return true } } -func rewriteValueMIPS_OpSqrt(v *Value) bool { +func rewriteValueMIPS_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (SQRTD x) @@ -8527,7 +8543,7 @@ func rewriteValueMIPS_OpSqrt(v *Value) bool { return true } } -func rewriteValueMIPS_OpStaticCall(v *Value) bool { +func rewriteValueMIPS_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -8542,7 +8558,7 @@ func rewriteValueMIPS_OpStaticCall(v *Value) bool { return true } } -func rewriteValueMIPS_OpStore(v *Value) bool { +func rewriteValueMIPS_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -8630,7 +8646,7 @@ func rewriteValueMIPS_OpStore(v *Value) bool { } return false } -func rewriteValueMIPS_OpSub16(v *Value) bool { +func rewriteValueMIPS_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -8643,7 +8659,7 @@ func rewriteValueMIPS_OpSub16(v *Value) bool { return true } } -func rewriteValueMIPS_OpSub32(v *Value) bool { +func rewriteValueMIPS_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -8656,7 +8672,7 @@ func rewriteValueMIPS_OpSub32(v *Value) bool { return true } } -func rewriteValueMIPS_OpSub32F(v *Value) bool { +func rewriteValueMIPS_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -8669,7 +8685,7 @@ func rewriteValueMIPS_OpSub32F(v *Value) bool { return true } } -func rewriteValueMIPS_OpSub32withcarry(v *Value) bool { +func rewriteValueMIPS_OpSub32withcarry_0(v *Value) bool { b := v.Block _ = b // match: (Sub32withcarry x y c) @@ -8689,7 +8705,7 @@ func rewriteValueMIPS_OpSub32withcarry(v *Value) bool { return true } } -func rewriteValueMIPS_OpSub64F(v *Value) bool { +func rewriteValueMIPS_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -8702,7 +8718,7 @@ func rewriteValueMIPS_OpSub64F(v *Value) bool { return true } } -func rewriteValueMIPS_OpSub8(v *Value) bool { +func rewriteValueMIPS_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -8715,7 +8731,7 @@ func rewriteValueMIPS_OpSub8(v *Value) bool { return true } } -func rewriteValueMIPS_OpSubPtr(v *Value) bool { +func rewriteValueMIPS_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -8728,7 +8744,7 @@ func rewriteValueMIPS_OpSubPtr(v *Value) bool { return true } } -func rewriteValueMIPS_OpTrunc16to8(v *Value) bool { +func rewriteValueMIPS_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -8740,7 +8756,7 @@ func rewriteValueMIPS_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueMIPS_OpTrunc32to16(v *Value) bool { +func rewriteValueMIPS_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -8752,7 +8768,7 @@ func rewriteValueMIPS_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueMIPS_OpTrunc32to8(v *Value) bool { +func rewriteValueMIPS_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -8764,7 +8780,7 @@ func rewriteValueMIPS_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueMIPS_OpXor16(v *Value) bool { +func rewriteValueMIPS_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -8777,7 +8793,7 @@ func rewriteValueMIPS_OpXor16(v *Value) bool { return true } } -func rewriteValueMIPS_OpXor32(v *Value) bool { +func rewriteValueMIPS_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -8790,7 +8806,7 @@ func rewriteValueMIPS_OpXor32(v *Value) bool { return true } } -func rewriteValueMIPS_OpXor8(v *Value) bool { +func rewriteValueMIPS_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -8803,11 +8819,9 @@ func rewriteValueMIPS_OpXor8(v *Value) bool { return true } } -func rewriteValueMIPS_OpZero(v *Value) bool { +func rewriteValueMIPS_OpZero_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Zero [0] _ mem) @@ -9072,6 +9086,15 @@ func rewriteValueMIPS_OpZero(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueMIPS_OpZero_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Zero [12] {t} ptr mem) // cond: t.(Type).Alignment()%4 == 0 // result: (MOVWstore [8] ptr (MOVWconst [0]) (MOVWstore [4] ptr (MOVWconst [0]) (MOVWstore [0] ptr (MOVWconst [0]) mem))) @@ -9174,7 +9197,7 @@ func rewriteValueMIPS_OpZero(v *Value) bool { } return false } -func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool { +func rewriteValueMIPS_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -9185,7 +9208,7 @@ func rewriteValueMIPS_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool { +func rewriteValueMIPS_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -9196,7 +9219,7 @@ func rewriteValueMIPS_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool { +func rewriteValueMIPS_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -9207,7 +9230,7 @@ func rewriteValueMIPS_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueMIPS_OpZeromask(v *Value) bool { +func rewriteValueMIPS_OpZeromask_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types diff --git a/src/cmd/compile/internal/ssa/rewriteMIPS64.go b/src/cmd/compile/internal/ssa/rewriteMIPS64.go index 3c23d2d602..7958537a8c 100644 --- a/src/cmd/compile/internal/ssa/rewriteMIPS64.go +++ b/src/cmd/compile/internal/ssa/rewriteMIPS64.go @@ -14,563 +14,563 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueMIPS64(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueMIPS64_OpAdd16(v) + return rewriteValueMIPS64_OpAdd16_0(v) case OpAdd32: - return rewriteValueMIPS64_OpAdd32(v) + return rewriteValueMIPS64_OpAdd32_0(v) case OpAdd32F: - return rewriteValueMIPS64_OpAdd32F(v) + return rewriteValueMIPS64_OpAdd32F_0(v) case OpAdd64: - return rewriteValueMIPS64_OpAdd64(v) + return rewriteValueMIPS64_OpAdd64_0(v) case OpAdd64F: - return rewriteValueMIPS64_OpAdd64F(v) + return rewriteValueMIPS64_OpAdd64F_0(v) case OpAdd8: - return rewriteValueMIPS64_OpAdd8(v) + return rewriteValueMIPS64_OpAdd8_0(v) case OpAddPtr: - return rewriteValueMIPS64_OpAddPtr(v) + return rewriteValueMIPS64_OpAddPtr_0(v) case OpAddr: - return rewriteValueMIPS64_OpAddr(v) + return rewriteValueMIPS64_OpAddr_0(v) case OpAnd16: - return rewriteValueMIPS64_OpAnd16(v) + return rewriteValueMIPS64_OpAnd16_0(v) case OpAnd32: - return rewriteValueMIPS64_OpAnd32(v) + return rewriteValueMIPS64_OpAnd32_0(v) case OpAnd64: - return rewriteValueMIPS64_OpAnd64(v) + return rewriteValueMIPS64_OpAnd64_0(v) case OpAnd8: - return rewriteValueMIPS64_OpAnd8(v) + return rewriteValueMIPS64_OpAnd8_0(v) case OpAndB: - return rewriteValueMIPS64_OpAndB(v) + return rewriteValueMIPS64_OpAndB_0(v) case OpAvg64u: - return rewriteValueMIPS64_OpAvg64u(v) + return rewriteValueMIPS64_OpAvg64u_0(v) case OpClosureCall: - return rewriteValueMIPS64_OpClosureCall(v) + return rewriteValueMIPS64_OpClosureCall_0(v) case OpCom16: - return rewriteValueMIPS64_OpCom16(v) + return rewriteValueMIPS64_OpCom16_0(v) case OpCom32: - return rewriteValueMIPS64_OpCom32(v) + return rewriteValueMIPS64_OpCom32_0(v) case OpCom64: - return rewriteValueMIPS64_OpCom64(v) + return rewriteValueMIPS64_OpCom64_0(v) case OpCom8: - return rewriteValueMIPS64_OpCom8(v) + return rewriteValueMIPS64_OpCom8_0(v) case OpConst16: - return rewriteValueMIPS64_OpConst16(v) + return rewriteValueMIPS64_OpConst16_0(v) case OpConst32: - return rewriteValueMIPS64_OpConst32(v) + return rewriteValueMIPS64_OpConst32_0(v) case OpConst32F: - return rewriteValueMIPS64_OpConst32F(v) + return rewriteValueMIPS64_OpConst32F_0(v) case OpConst64: - return rewriteValueMIPS64_OpConst64(v) + return rewriteValueMIPS64_OpConst64_0(v) case OpConst64F: - return rewriteValueMIPS64_OpConst64F(v) + return rewriteValueMIPS64_OpConst64F_0(v) case OpConst8: - return rewriteValueMIPS64_OpConst8(v) + return rewriteValueMIPS64_OpConst8_0(v) case OpConstBool: - return rewriteValueMIPS64_OpConstBool(v) + return rewriteValueMIPS64_OpConstBool_0(v) case OpConstNil: - return rewriteValueMIPS64_OpConstNil(v) + return rewriteValueMIPS64_OpConstNil_0(v) case OpConvert: - return rewriteValueMIPS64_OpConvert(v) + return rewriteValueMIPS64_OpConvert_0(v) case OpCvt32Fto32: - return rewriteValueMIPS64_OpCvt32Fto32(v) + return rewriteValueMIPS64_OpCvt32Fto32_0(v) case OpCvt32Fto64: - return rewriteValueMIPS64_OpCvt32Fto64(v) + return rewriteValueMIPS64_OpCvt32Fto64_0(v) case OpCvt32Fto64F: - return rewriteValueMIPS64_OpCvt32Fto64F(v) + return rewriteValueMIPS64_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValueMIPS64_OpCvt32to32F(v) + return rewriteValueMIPS64_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueMIPS64_OpCvt32to64F(v) + return rewriteValueMIPS64_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueMIPS64_OpCvt64Fto32(v) + return rewriteValueMIPS64_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueMIPS64_OpCvt64Fto32F(v) + return rewriteValueMIPS64_OpCvt64Fto32F_0(v) case OpCvt64Fto64: - return rewriteValueMIPS64_OpCvt64Fto64(v) + return rewriteValueMIPS64_OpCvt64Fto64_0(v) case OpCvt64to32F: - return rewriteValueMIPS64_OpCvt64to32F(v) + return rewriteValueMIPS64_OpCvt64to32F_0(v) case OpCvt64to64F: - return rewriteValueMIPS64_OpCvt64to64F(v) + return rewriteValueMIPS64_OpCvt64to64F_0(v) case OpDiv16: - return rewriteValueMIPS64_OpDiv16(v) + return rewriteValueMIPS64_OpDiv16_0(v) case OpDiv16u: - return rewriteValueMIPS64_OpDiv16u(v) + return rewriteValueMIPS64_OpDiv16u_0(v) case OpDiv32: - return rewriteValueMIPS64_OpDiv32(v) + return rewriteValueMIPS64_OpDiv32_0(v) case OpDiv32F: - return rewriteValueMIPS64_OpDiv32F(v) + return rewriteValueMIPS64_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueMIPS64_OpDiv32u(v) + return rewriteValueMIPS64_OpDiv32u_0(v) case OpDiv64: - return rewriteValueMIPS64_OpDiv64(v) + return rewriteValueMIPS64_OpDiv64_0(v) case OpDiv64F: - return rewriteValueMIPS64_OpDiv64F(v) + return rewriteValueMIPS64_OpDiv64F_0(v) case OpDiv64u: - return rewriteValueMIPS64_OpDiv64u(v) + return rewriteValueMIPS64_OpDiv64u_0(v) case OpDiv8: - return rewriteValueMIPS64_OpDiv8(v) + return rewriteValueMIPS64_OpDiv8_0(v) case OpDiv8u: - return rewriteValueMIPS64_OpDiv8u(v) + return rewriteValueMIPS64_OpDiv8u_0(v) case OpEq16: - return rewriteValueMIPS64_OpEq16(v) + return rewriteValueMIPS64_OpEq16_0(v) case OpEq32: - return rewriteValueMIPS64_OpEq32(v) + return rewriteValueMIPS64_OpEq32_0(v) case OpEq32F: - return rewriteValueMIPS64_OpEq32F(v) + return rewriteValueMIPS64_OpEq32F_0(v) case OpEq64: - return rewriteValueMIPS64_OpEq64(v) + return rewriteValueMIPS64_OpEq64_0(v) case OpEq64F: - return rewriteValueMIPS64_OpEq64F(v) + return rewriteValueMIPS64_OpEq64F_0(v) case OpEq8: - return rewriteValueMIPS64_OpEq8(v) + return rewriteValueMIPS64_OpEq8_0(v) case OpEqB: - return rewriteValueMIPS64_OpEqB(v) + return rewriteValueMIPS64_OpEqB_0(v) case OpEqPtr: - return rewriteValueMIPS64_OpEqPtr(v) + return rewriteValueMIPS64_OpEqPtr_0(v) case OpGeq16: - return rewriteValueMIPS64_OpGeq16(v) + return rewriteValueMIPS64_OpGeq16_0(v) case OpGeq16U: - return rewriteValueMIPS64_OpGeq16U(v) + return rewriteValueMIPS64_OpGeq16U_0(v) case OpGeq32: - return rewriteValueMIPS64_OpGeq32(v) + return rewriteValueMIPS64_OpGeq32_0(v) case OpGeq32F: - return rewriteValueMIPS64_OpGeq32F(v) + return rewriteValueMIPS64_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueMIPS64_OpGeq32U(v) + return rewriteValueMIPS64_OpGeq32U_0(v) case OpGeq64: - return rewriteValueMIPS64_OpGeq64(v) + return rewriteValueMIPS64_OpGeq64_0(v) case OpGeq64F: - return rewriteValueMIPS64_OpGeq64F(v) + return rewriteValueMIPS64_OpGeq64F_0(v) case OpGeq64U: - return rewriteValueMIPS64_OpGeq64U(v) + return rewriteValueMIPS64_OpGeq64U_0(v) case OpGeq8: - return rewriteValueMIPS64_OpGeq8(v) + return rewriteValueMIPS64_OpGeq8_0(v) case OpGeq8U: - return rewriteValueMIPS64_OpGeq8U(v) + return rewriteValueMIPS64_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueMIPS64_OpGetClosurePtr(v) + return rewriteValueMIPS64_OpGetClosurePtr_0(v) case OpGreater16: - return rewriteValueMIPS64_OpGreater16(v) + return rewriteValueMIPS64_OpGreater16_0(v) case OpGreater16U: - return rewriteValueMIPS64_OpGreater16U(v) + return rewriteValueMIPS64_OpGreater16U_0(v) case OpGreater32: - return rewriteValueMIPS64_OpGreater32(v) + return rewriteValueMIPS64_OpGreater32_0(v) case OpGreater32F: - return rewriteValueMIPS64_OpGreater32F(v) + return rewriteValueMIPS64_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueMIPS64_OpGreater32U(v) + return rewriteValueMIPS64_OpGreater32U_0(v) case OpGreater64: - return rewriteValueMIPS64_OpGreater64(v) + return rewriteValueMIPS64_OpGreater64_0(v) case OpGreater64F: - return rewriteValueMIPS64_OpGreater64F(v) + return rewriteValueMIPS64_OpGreater64F_0(v) case OpGreater64U: - return rewriteValueMIPS64_OpGreater64U(v) + return rewriteValueMIPS64_OpGreater64U_0(v) case OpGreater8: - return rewriteValueMIPS64_OpGreater8(v) + return rewriteValueMIPS64_OpGreater8_0(v) case OpGreater8U: - return rewriteValueMIPS64_OpGreater8U(v) + return rewriteValueMIPS64_OpGreater8U_0(v) case OpHmul32: - return rewriteValueMIPS64_OpHmul32(v) + return rewriteValueMIPS64_OpHmul32_0(v) case OpHmul32u: - return rewriteValueMIPS64_OpHmul32u(v) + return rewriteValueMIPS64_OpHmul32u_0(v) case OpHmul64: - return rewriteValueMIPS64_OpHmul64(v) + return rewriteValueMIPS64_OpHmul64_0(v) case OpHmul64u: - return rewriteValueMIPS64_OpHmul64u(v) + return rewriteValueMIPS64_OpHmul64u_0(v) case OpInterCall: - return rewriteValueMIPS64_OpInterCall(v) + return rewriteValueMIPS64_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueMIPS64_OpIsInBounds(v) + return rewriteValueMIPS64_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueMIPS64_OpIsNonNil(v) + return rewriteValueMIPS64_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueMIPS64_OpIsSliceInBounds(v) + return rewriteValueMIPS64_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueMIPS64_OpLeq16(v) + return rewriteValueMIPS64_OpLeq16_0(v) case OpLeq16U: - return rewriteValueMIPS64_OpLeq16U(v) + return rewriteValueMIPS64_OpLeq16U_0(v) case OpLeq32: - return rewriteValueMIPS64_OpLeq32(v) + return rewriteValueMIPS64_OpLeq32_0(v) case OpLeq32F: - return rewriteValueMIPS64_OpLeq32F(v) + return rewriteValueMIPS64_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueMIPS64_OpLeq32U(v) + return rewriteValueMIPS64_OpLeq32U_0(v) case OpLeq64: - return rewriteValueMIPS64_OpLeq64(v) + return rewriteValueMIPS64_OpLeq64_0(v) case OpLeq64F: - return rewriteValueMIPS64_OpLeq64F(v) + return rewriteValueMIPS64_OpLeq64F_0(v) case OpLeq64U: - return rewriteValueMIPS64_OpLeq64U(v) + return rewriteValueMIPS64_OpLeq64U_0(v) case OpLeq8: - return rewriteValueMIPS64_OpLeq8(v) + return rewriteValueMIPS64_OpLeq8_0(v) case OpLeq8U: - return rewriteValueMIPS64_OpLeq8U(v) + return rewriteValueMIPS64_OpLeq8U_0(v) case OpLess16: - return rewriteValueMIPS64_OpLess16(v) + return rewriteValueMIPS64_OpLess16_0(v) case OpLess16U: - return rewriteValueMIPS64_OpLess16U(v) + return rewriteValueMIPS64_OpLess16U_0(v) case OpLess32: - return rewriteValueMIPS64_OpLess32(v) + return rewriteValueMIPS64_OpLess32_0(v) case OpLess32F: - return rewriteValueMIPS64_OpLess32F(v) + return rewriteValueMIPS64_OpLess32F_0(v) case OpLess32U: - return rewriteValueMIPS64_OpLess32U(v) + return rewriteValueMIPS64_OpLess32U_0(v) case OpLess64: - return rewriteValueMIPS64_OpLess64(v) + return rewriteValueMIPS64_OpLess64_0(v) case OpLess64F: - return rewriteValueMIPS64_OpLess64F(v) + return rewriteValueMIPS64_OpLess64F_0(v) case OpLess64U: - return rewriteValueMIPS64_OpLess64U(v) + return rewriteValueMIPS64_OpLess64U_0(v) case OpLess8: - return rewriteValueMIPS64_OpLess8(v) + return rewriteValueMIPS64_OpLess8_0(v) case OpLess8U: - return rewriteValueMIPS64_OpLess8U(v) + return rewriteValueMIPS64_OpLess8U_0(v) case OpLoad: - return rewriteValueMIPS64_OpLoad(v) + return rewriteValueMIPS64_OpLoad_0(v) case OpLsh16x16: - return rewriteValueMIPS64_OpLsh16x16(v) + return rewriteValueMIPS64_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueMIPS64_OpLsh16x32(v) + return rewriteValueMIPS64_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueMIPS64_OpLsh16x64(v) + return rewriteValueMIPS64_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueMIPS64_OpLsh16x8(v) + return rewriteValueMIPS64_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueMIPS64_OpLsh32x16(v) + return rewriteValueMIPS64_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueMIPS64_OpLsh32x32(v) + return rewriteValueMIPS64_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueMIPS64_OpLsh32x64(v) + return rewriteValueMIPS64_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueMIPS64_OpLsh32x8(v) + return rewriteValueMIPS64_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValueMIPS64_OpLsh64x16(v) + return rewriteValueMIPS64_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValueMIPS64_OpLsh64x32(v) + return rewriteValueMIPS64_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValueMIPS64_OpLsh64x64(v) + return rewriteValueMIPS64_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValueMIPS64_OpLsh64x8(v) + return rewriteValueMIPS64_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValueMIPS64_OpLsh8x16(v) + return rewriteValueMIPS64_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueMIPS64_OpLsh8x32(v) + return rewriteValueMIPS64_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueMIPS64_OpLsh8x64(v) + return rewriteValueMIPS64_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueMIPS64_OpLsh8x8(v) + return rewriteValueMIPS64_OpLsh8x8_0(v) case OpMIPS64ADDV: - return rewriteValueMIPS64_OpMIPS64ADDV(v) + return rewriteValueMIPS64_OpMIPS64ADDV_0(v) case OpMIPS64ADDVconst: - return rewriteValueMIPS64_OpMIPS64ADDVconst(v) + return rewriteValueMIPS64_OpMIPS64ADDVconst_0(v) case OpMIPS64AND: - return rewriteValueMIPS64_OpMIPS64AND(v) + return rewriteValueMIPS64_OpMIPS64AND_0(v) case OpMIPS64ANDconst: - return rewriteValueMIPS64_OpMIPS64ANDconst(v) + return rewriteValueMIPS64_OpMIPS64ANDconst_0(v) case OpMIPS64MOVBUload: - return rewriteValueMIPS64_OpMIPS64MOVBUload(v) + return rewriteValueMIPS64_OpMIPS64MOVBUload_0(v) case OpMIPS64MOVBUreg: - return rewriteValueMIPS64_OpMIPS64MOVBUreg(v) + return rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v) case OpMIPS64MOVBload: - return rewriteValueMIPS64_OpMIPS64MOVBload(v) + return rewriteValueMIPS64_OpMIPS64MOVBload_0(v) case OpMIPS64MOVBreg: - return rewriteValueMIPS64_OpMIPS64MOVBreg(v) + return rewriteValueMIPS64_OpMIPS64MOVBreg_0(v) case OpMIPS64MOVBstore: - return rewriteValueMIPS64_OpMIPS64MOVBstore(v) + return rewriteValueMIPS64_OpMIPS64MOVBstore_0(v) case OpMIPS64MOVBstorezero: - return rewriteValueMIPS64_OpMIPS64MOVBstorezero(v) + return rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v) case OpMIPS64MOVDload: - return rewriteValueMIPS64_OpMIPS64MOVDload(v) + return rewriteValueMIPS64_OpMIPS64MOVDload_0(v) case OpMIPS64MOVDstore: - return rewriteValueMIPS64_OpMIPS64MOVDstore(v) + return rewriteValueMIPS64_OpMIPS64MOVDstore_0(v) case OpMIPS64MOVFload: - return rewriteValueMIPS64_OpMIPS64MOVFload(v) + return rewriteValueMIPS64_OpMIPS64MOVFload_0(v) case OpMIPS64MOVFstore: - return rewriteValueMIPS64_OpMIPS64MOVFstore(v) + return rewriteValueMIPS64_OpMIPS64MOVFstore_0(v) case OpMIPS64MOVHUload: - return rewriteValueMIPS64_OpMIPS64MOVHUload(v) + return rewriteValueMIPS64_OpMIPS64MOVHUload_0(v) case OpMIPS64MOVHUreg: - return rewriteValueMIPS64_OpMIPS64MOVHUreg(v) + return rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v) case OpMIPS64MOVHload: - return rewriteValueMIPS64_OpMIPS64MOVHload(v) + return rewriteValueMIPS64_OpMIPS64MOVHload_0(v) case OpMIPS64MOVHreg: - return rewriteValueMIPS64_OpMIPS64MOVHreg(v) + return rewriteValueMIPS64_OpMIPS64MOVHreg_0(v) case OpMIPS64MOVHstore: - return rewriteValueMIPS64_OpMIPS64MOVHstore(v) + return rewriteValueMIPS64_OpMIPS64MOVHstore_0(v) case OpMIPS64MOVHstorezero: - return rewriteValueMIPS64_OpMIPS64MOVHstorezero(v) + return rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v) case OpMIPS64MOVVload: - return rewriteValueMIPS64_OpMIPS64MOVVload(v) + return rewriteValueMIPS64_OpMIPS64MOVVload_0(v) case OpMIPS64MOVVreg: - return rewriteValueMIPS64_OpMIPS64MOVVreg(v) + return rewriteValueMIPS64_OpMIPS64MOVVreg_0(v) case OpMIPS64MOVVstore: - return rewriteValueMIPS64_OpMIPS64MOVVstore(v) + return rewriteValueMIPS64_OpMIPS64MOVVstore_0(v) case OpMIPS64MOVVstorezero: - return rewriteValueMIPS64_OpMIPS64MOVVstorezero(v) + return rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v) case OpMIPS64MOVWUload: - return rewriteValueMIPS64_OpMIPS64MOVWUload(v) + return rewriteValueMIPS64_OpMIPS64MOVWUload_0(v) case OpMIPS64MOVWUreg: - return rewriteValueMIPS64_OpMIPS64MOVWUreg(v) + return rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v) case OpMIPS64MOVWload: - return rewriteValueMIPS64_OpMIPS64MOVWload(v) + return rewriteValueMIPS64_OpMIPS64MOVWload_0(v) case OpMIPS64MOVWreg: - return rewriteValueMIPS64_OpMIPS64MOVWreg(v) + return rewriteValueMIPS64_OpMIPS64MOVWreg_0(v) || rewriteValueMIPS64_OpMIPS64MOVWreg_10(v) case OpMIPS64MOVWstore: - return rewriteValueMIPS64_OpMIPS64MOVWstore(v) + return rewriteValueMIPS64_OpMIPS64MOVWstore_0(v) case OpMIPS64MOVWstorezero: - return rewriteValueMIPS64_OpMIPS64MOVWstorezero(v) + return rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v) case OpMIPS64NEGV: - return rewriteValueMIPS64_OpMIPS64NEGV(v) + return rewriteValueMIPS64_OpMIPS64NEGV_0(v) case OpMIPS64NOR: - return rewriteValueMIPS64_OpMIPS64NOR(v) + return rewriteValueMIPS64_OpMIPS64NOR_0(v) case OpMIPS64NORconst: - return rewriteValueMIPS64_OpMIPS64NORconst(v) + return rewriteValueMIPS64_OpMIPS64NORconst_0(v) case OpMIPS64OR: - return rewriteValueMIPS64_OpMIPS64OR(v) + return rewriteValueMIPS64_OpMIPS64OR_0(v) case OpMIPS64ORconst: - return rewriteValueMIPS64_OpMIPS64ORconst(v) + return rewriteValueMIPS64_OpMIPS64ORconst_0(v) case OpMIPS64SGT: - return rewriteValueMIPS64_OpMIPS64SGT(v) + return rewriteValueMIPS64_OpMIPS64SGT_0(v) case OpMIPS64SGTU: - return rewriteValueMIPS64_OpMIPS64SGTU(v) + return rewriteValueMIPS64_OpMIPS64SGTU_0(v) case OpMIPS64SGTUconst: - return rewriteValueMIPS64_OpMIPS64SGTUconst(v) + return rewriteValueMIPS64_OpMIPS64SGTUconst_0(v) case OpMIPS64SGTconst: - return rewriteValueMIPS64_OpMIPS64SGTconst(v) + return rewriteValueMIPS64_OpMIPS64SGTconst_0(v) || rewriteValueMIPS64_OpMIPS64SGTconst_10(v) case OpMIPS64SLLV: - return rewriteValueMIPS64_OpMIPS64SLLV(v) + return rewriteValueMIPS64_OpMIPS64SLLV_0(v) case OpMIPS64SLLVconst: - return rewriteValueMIPS64_OpMIPS64SLLVconst(v) + return rewriteValueMIPS64_OpMIPS64SLLVconst_0(v) case OpMIPS64SRAV: - return rewriteValueMIPS64_OpMIPS64SRAV(v) + return rewriteValueMIPS64_OpMIPS64SRAV_0(v) case OpMIPS64SRAVconst: - return rewriteValueMIPS64_OpMIPS64SRAVconst(v) + return rewriteValueMIPS64_OpMIPS64SRAVconst_0(v) case OpMIPS64SRLV: - return rewriteValueMIPS64_OpMIPS64SRLV(v) + return rewriteValueMIPS64_OpMIPS64SRLV_0(v) case OpMIPS64SRLVconst: - return rewriteValueMIPS64_OpMIPS64SRLVconst(v) + return rewriteValueMIPS64_OpMIPS64SRLVconst_0(v) case OpMIPS64SUBV: - return rewriteValueMIPS64_OpMIPS64SUBV(v) + return rewriteValueMIPS64_OpMIPS64SUBV_0(v) case OpMIPS64SUBVconst: - return rewriteValueMIPS64_OpMIPS64SUBVconst(v) + return rewriteValueMIPS64_OpMIPS64SUBVconst_0(v) case OpMIPS64XOR: - return rewriteValueMIPS64_OpMIPS64XOR(v) + return rewriteValueMIPS64_OpMIPS64XOR_0(v) case OpMIPS64XORconst: - return rewriteValueMIPS64_OpMIPS64XORconst(v) + return rewriteValueMIPS64_OpMIPS64XORconst_0(v) case OpMod16: - return rewriteValueMIPS64_OpMod16(v) + return rewriteValueMIPS64_OpMod16_0(v) case OpMod16u: - return rewriteValueMIPS64_OpMod16u(v) + return rewriteValueMIPS64_OpMod16u_0(v) case OpMod32: - return rewriteValueMIPS64_OpMod32(v) + return rewriteValueMIPS64_OpMod32_0(v) case OpMod32u: - return rewriteValueMIPS64_OpMod32u(v) + return rewriteValueMIPS64_OpMod32u_0(v) case OpMod64: - return rewriteValueMIPS64_OpMod64(v) + return rewriteValueMIPS64_OpMod64_0(v) case OpMod64u: - return rewriteValueMIPS64_OpMod64u(v) + return rewriteValueMIPS64_OpMod64u_0(v) case OpMod8: - return rewriteValueMIPS64_OpMod8(v) + return rewriteValueMIPS64_OpMod8_0(v) case OpMod8u: - return rewriteValueMIPS64_OpMod8u(v) + return rewriteValueMIPS64_OpMod8u_0(v) case OpMove: - return rewriteValueMIPS64_OpMove(v) + return rewriteValueMIPS64_OpMove_0(v) || rewriteValueMIPS64_OpMove_10(v) case OpMul16: - return rewriteValueMIPS64_OpMul16(v) + return rewriteValueMIPS64_OpMul16_0(v) case OpMul32: - return rewriteValueMIPS64_OpMul32(v) + return rewriteValueMIPS64_OpMul32_0(v) case OpMul32F: - return rewriteValueMIPS64_OpMul32F(v) + return rewriteValueMIPS64_OpMul32F_0(v) case OpMul64: - return rewriteValueMIPS64_OpMul64(v) + return rewriteValueMIPS64_OpMul64_0(v) case OpMul64F: - return rewriteValueMIPS64_OpMul64F(v) + return rewriteValueMIPS64_OpMul64F_0(v) case OpMul8: - return rewriteValueMIPS64_OpMul8(v) + return rewriteValueMIPS64_OpMul8_0(v) case OpNeg16: - return rewriteValueMIPS64_OpNeg16(v) + return rewriteValueMIPS64_OpNeg16_0(v) case OpNeg32: - return rewriteValueMIPS64_OpNeg32(v) + return rewriteValueMIPS64_OpNeg32_0(v) case OpNeg32F: - return rewriteValueMIPS64_OpNeg32F(v) + return rewriteValueMIPS64_OpNeg32F_0(v) case OpNeg64: - return rewriteValueMIPS64_OpNeg64(v) + return rewriteValueMIPS64_OpNeg64_0(v) case OpNeg64F: - return rewriteValueMIPS64_OpNeg64F(v) + return rewriteValueMIPS64_OpNeg64F_0(v) case OpNeg8: - return rewriteValueMIPS64_OpNeg8(v) + return rewriteValueMIPS64_OpNeg8_0(v) case OpNeq16: - return rewriteValueMIPS64_OpNeq16(v) + return rewriteValueMIPS64_OpNeq16_0(v) case OpNeq32: - return rewriteValueMIPS64_OpNeq32(v) + return rewriteValueMIPS64_OpNeq32_0(v) case OpNeq32F: - return rewriteValueMIPS64_OpNeq32F(v) + return rewriteValueMIPS64_OpNeq32F_0(v) case OpNeq64: - return rewriteValueMIPS64_OpNeq64(v) + return rewriteValueMIPS64_OpNeq64_0(v) case OpNeq64F: - return rewriteValueMIPS64_OpNeq64F(v) + return rewriteValueMIPS64_OpNeq64F_0(v) case OpNeq8: - return rewriteValueMIPS64_OpNeq8(v) + return rewriteValueMIPS64_OpNeq8_0(v) case OpNeqB: - return rewriteValueMIPS64_OpNeqB(v) + return rewriteValueMIPS64_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueMIPS64_OpNeqPtr(v) + return rewriteValueMIPS64_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueMIPS64_OpNilCheck(v) + return rewriteValueMIPS64_OpNilCheck_0(v) case OpNot: - return rewriteValueMIPS64_OpNot(v) + return rewriteValueMIPS64_OpNot_0(v) case OpOffPtr: - return rewriteValueMIPS64_OpOffPtr(v) + return rewriteValueMIPS64_OpOffPtr_0(v) case OpOr16: - return rewriteValueMIPS64_OpOr16(v) + return rewriteValueMIPS64_OpOr16_0(v) case OpOr32: - return rewriteValueMIPS64_OpOr32(v) + return rewriteValueMIPS64_OpOr32_0(v) case OpOr64: - return rewriteValueMIPS64_OpOr64(v) + return rewriteValueMIPS64_OpOr64_0(v) case OpOr8: - return rewriteValueMIPS64_OpOr8(v) + return rewriteValueMIPS64_OpOr8_0(v) case OpOrB: - return rewriteValueMIPS64_OpOrB(v) + return rewriteValueMIPS64_OpOrB_0(v) case OpRound32F: - return rewriteValueMIPS64_OpRound32F(v) + return rewriteValueMIPS64_OpRound32F_0(v) case OpRound64F: - return rewriteValueMIPS64_OpRound64F(v) + return rewriteValueMIPS64_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueMIPS64_OpRsh16Ux16(v) + return rewriteValueMIPS64_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueMIPS64_OpRsh16Ux32(v) + return rewriteValueMIPS64_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueMIPS64_OpRsh16Ux64(v) + return rewriteValueMIPS64_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueMIPS64_OpRsh16Ux8(v) + return rewriteValueMIPS64_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueMIPS64_OpRsh16x16(v) + return rewriteValueMIPS64_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueMIPS64_OpRsh16x32(v) + return rewriteValueMIPS64_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueMIPS64_OpRsh16x64(v) + return rewriteValueMIPS64_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueMIPS64_OpRsh16x8(v) + return rewriteValueMIPS64_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueMIPS64_OpRsh32Ux16(v) + return rewriteValueMIPS64_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueMIPS64_OpRsh32Ux32(v) + return rewriteValueMIPS64_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueMIPS64_OpRsh32Ux64(v) + return rewriteValueMIPS64_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueMIPS64_OpRsh32Ux8(v) + return rewriteValueMIPS64_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueMIPS64_OpRsh32x16(v) + return rewriteValueMIPS64_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueMIPS64_OpRsh32x32(v) + return rewriteValueMIPS64_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueMIPS64_OpRsh32x64(v) + return rewriteValueMIPS64_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueMIPS64_OpRsh32x8(v) + return rewriteValueMIPS64_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValueMIPS64_OpRsh64Ux16(v) + return rewriteValueMIPS64_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValueMIPS64_OpRsh64Ux32(v) + return rewriteValueMIPS64_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValueMIPS64_OpRsh64Ux64(v) + return rewriteValueMIPS64_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValueMIPS64_OpRsh64Ux8(v) + return rewriteValueMIPS64_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValueMIPS64_OpRsh64x16(v) + return rewriteValueMIPS64_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValueMIPS64_OpRsh64x32(v) + return rewriteValueMIPS64_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValueMIPS64_OpRsh64x64(v) + return rewriteValueMIPS64_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValueMIPS64_OpRsh64x8(v) + return rewriteValueMIPS64_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValueMIPS64_OpRsh8Ux16(v) + return rewriteValueMIPS64_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueMIPS64_OpRsh8Ux32(v) + return rewriteValueMIPS64_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueMIPS64_OpRsh8Ux64(v) + return rewriteValueMIPS64_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueMIPS64_OpRsh8Ux8(v) + return rewriteValueMIPS64_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueMIPS64_OpRsh8x16(v) + return rewriteValueMIPS64_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueMIPS64_OpRsh8x32(v) + return rewriteValueMIPS64_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueMIPS64_OpRsh8x64(v) + return rewriteValueMIPS64_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueMIPS64_OpRsh8x8(v) + return rewriteValueMIPS64_OpRsh8x8_0(v) case OpSelect0: - return rewriteValueMIPS64_OpSelect0(v) + return rewriteValueMIPS64_OpSelect0_0(v) case OpSelect1: - return rewriteValueMIPS64_OpSelect1(v) + return rewriteValueMIPS64_OpSelect1_0(v) || rewriteValueMIPS64_OpSelect1_10(v) || rewriteValueMIPS64_OpSelect1_20(v) case OpSignExt16to32: - return rewriteValueMIPS64_OpSignExt16to32(v) + return rewriteValueMIPS64_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValueMIPS64_OpSignExt16to64(v) + return rewriteValueMIPS64_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValueMIPS64_OpSignExt32to64(v) + return rewriteValueMIPS64_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValueMIPS64_OpSignExt8to16(v) + return rewriteValueMIPS64_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueMIPS64_OpSignExt8to32(v) + return rewriteValueMIPS64_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValueMIPS64_OpSignExt8to64(v) + return rewriteValueMIPS64_OpSignExt8to64_0(v) case OpSlicemask: - return rewriteValueMIPS64_OpSlicemask(v) + return rewriteValueMIPS64_OpSlicemask_0(v) case OpStaticCall: - return rewriteValueMIPS64_OpStaticCall(v) + return rewriteValueMIPS64_OpStaticCall_0(v) case OpStore: - return rewriteValueMIPS64_OpStore(v) + return rewriteValueMIPS64_OpStore_0(v) case OpSub16: - return rewriteValueMIPS64_OpSub16(v) + return rewriteValueMIPS64_OpSub16_0(v) case OpSub32: - return rewriteValueMIPS64_OpSub32(v) + return rewriteValueMIPS64_OpSub32_0(v) case OpSub32F: - return rewriteValueMIPS64_OpSub32F(v) + return rewriteValueMIPS64_OpSub32F_0(v) case OpSub64: - return rewriteValueMIPS64_OpSub64(v) + return rewriteValueMIPS64_OpSub64_0(v) case OpSub64F: - return rewriteValueMIPS64_OpSub64F(v) + return rewriteValueMIPS64_OpSub64F_0(v) case OpSub8: - return rewriteValueMIPS64_OpSub8(v) + return rewriteValueMIPS64_OpSub8_0(v) case OpSubPtr: - return rewriteValueMIPS64_OpSubPtr(v) + return rewriteValueMIPS64_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueMIPS64_OpTrunc16to8(v) + return rewriteValueMIPS64_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueMIPS64_OpTrunc32to16(v) + return rewriteValueMIPS64_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueMIPS64_OpTrunc32to8(v) + return rewriteValueMIPS64_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValueMIPS64_OpTrunc64to16(v) + return rewriteValueMIPS64_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValueMIPS64_OpTrunc64to32(v) + return rewriteValueMIPS64_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValueMIPS64_OpTrunc64to8(v) + return rewriteValueMIPS64_OpTrunc64to8_0(v) case OpXor16: - return rewriteValueMIPS64_OpXor16(v) + return rewriteValueMIPS64_OpXor16_0(v) case OpXor32: - return rewriteValueMIPS64_OpXor32(v) + return rewriteValueMIPS64_OpXor32_0(v) case OpXor64: - return rewriteValueMIPS64_OpXor64(v) + return rewriteValueMIPS64_OpXor64_0(v) case OpXor8: - return rewriteValueMIPS64_OpXor8(v) + return rewriteValueMIPS64_OpXor8_0(v) case OpZero: - return rewriteValueMIPS64_OpZero(v) + return rewriteValueMIPS64_OpZero_0(v) || rewriteValueMIPS64_OpZero_10(v) case OpZeroExt16to32: - return rewriteValueMIPS64_OpZeroExt16to32(v) + return rewriteValueMIPS64_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValueMIPS64_OpZeroExt16to64(v) + return rewriteValueMIPS64_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValueMIPS64_OpZeroExt32to64(v) + return rewriteValueMIPS64_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValueMIPS64_OpZeroExt8to16(v) + return rewriteValueMIPS64_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueMIPS64_OpZeroExt8to32(v) + return rewriteValueMIPS64_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValueMIPS64_OpZeroExt8to64(v) + return rewriteValueMIPS64_OpZeroExt8to64_0(v) } return false } -func rewriteValueMIPS64_OpAdd16(v *Value) bool { +func rewriteValueMIPS64_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDV x y) @@ -583,7 +583,7 @@ func rewriteValueMIPS64_OpAdd16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAdd32(v *Value) bool { +func rewriteValueMIPS64_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDV x y) @@ -596,7 +596,7 @@ func rewriteValueMIPS64_OpAdd32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAdd32F(v *Value) bool { +func rewriteValueMIPS64_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (ADDF x y) @@ -609,7 +609,7 @@ func rewriteValueMIPS64_OpAdd32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAdd64(v *Value) bool { +func rewriteValueMIPS64_OpAdd64_0(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADDV x y) @@ -622,7 +622,7 @@ func rewriteValueMIPS64_OpAdd64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAdd64F(v *Value) bool { +func rewriteValueMIPS64_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (ADDD x y) @@ -635,7 +635,7 @@ func rewriteValueMIPS64_OpAdd64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAdd8(v *Value) bool { +func rewriteValueMIPS64_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDV x y) @@ -648,7 +648,7 @@ func rewriteValueMIPS64_OpAdd8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAddPtr(v *Value) bool { +func rewriteValueMIPS64_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADDV x y) @@ -661,7 +661,7 @@ func rewriteValueMIPS64_OpAddPtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAddr(v *Value) bool { +func rewriteValueMIPS64_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVVaddr {sym} base) @@ -674,7 +674,7 @@ func rewriteValueMIPS64_OpAddr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAnd16(v *Value) bool { +func rewriteValueMIPS64_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -687,7 +687,7 @@ func rewriteValueMIPS64_OpAnd16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAnd32(v *Value) bool { +func rewriteValueMIPS64_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -700,7 +700,7 @@ func rewriteValueMIPS64_OpAnd32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAnd64(v *Value) bool { +func rewriteValueMIPS64_OpAnd64_0(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -713,7 +713,7 @@ func rewriteValueMIPS64_OpAnd64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAnd8(v *Value) bool { +func rewriteValueMIPS64_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -726,7 +726,7 @@ func rewriteValueMIPS64_OpAnd8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAndB(v *Value) bool { +func rewriteValueMIPS64_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -739,7 +739,7 @@ func rewriteValueMIPS64_OpAndB(v *Value) bool { return true } } -func rewriteValueMIPS64_OpAvg64u(v *Value) bool { +func rewriteValueMIPS64_OpAvg64u_0(v *Value) bool { b := v.Block _ = b // match: (Avg64u x y) @@ -761,7 +761,7 @@ func rewriteValueMIPS64_OpAvg64u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpClosureCall(v *Value) bool { +func rewriteValueMIPS64_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -778,7 +778,7 @@ func rewriteValueMIPS64_OpClosureCall(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCom16(v *Value) bool { +func rewriteValueMIPS64_OpCom16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -796,7 +796,7 @@ func rewriteValueMIPS64_OpCom16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCom32(v *Value) bool { +func rewriteValueMIPS64_OpCom32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -814,7 +814,7 @@ func rewriteValueMIPS64_OpCom32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCom64(v *Value) bool { +func rewriteValueMIPS64_OpCom64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -832,7 +832,7 @@ func rewriteValueMIPS64_OpCom64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCom8(v *Value) bool { +func rewriteValueMIPS64_OpCom8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -850,7 +850,7 @@ func rewriteValueMIPS64_OpCom8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst16(v *Value) bool { +func rewriteValueMIPS64_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVVconst [val]) @@ -861,7 +861,7 @@ func rewriteValueMIPS64_OpConst16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst32(v *Value) bool { +func rewriteValueMIPS64_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVVconst [val]) @@ -872,7 +872,7 @@ func rewriteValueMIPS64_OpConst32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst32F(v *Value) bool { +func rewriteValueMIPS64_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (MOVFconst [val]) @@ -883,7 +883,7 @@ func rewriteValueMIPS64_OpConst32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst64(v *Value) bool { +func rewriteValueMIPS64_OpConst64_0(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVVconst [val]) @@ -894,7 +894,7 @@ func rewriteValueMIPS64_OpConst64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst64F(v *Value) bool { +func rewriteValueMIPS64_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (MOVDconst [val]) @@ -905,7 +905,7 @@ func rewriteValueMIPS64_OpConst64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConst8(v *Value) bool { +func rewriteValueMIPS64_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVVconst [val]) @@ -916,7 +916,7 @@ func rewriteValueMIPS64_OpConst8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConstBool(v *Value) bool { +func rewriteValueMIPS64_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVVconst [b]) @@ -927,7 +927,7 @@ func rewriteValueMIPS64_OpConstBool(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConstNil(v *Value) bool { +func rewriteValueMIPS64_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVVconst [0]) @@ -937,7 +937,7 @@ func rewriteValueMIPS64_OpConstNil(v *Value) bool { return true } } -func rewriteValueMIPS64_OpConvert(v *Value) bool { +func rewriteValueMIPS64_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVVconvert x mem) @@ -950,7 +950,7 @@ func rewriteValueMIPS64_OpConvert(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool { +func rewriteValueMIPS64_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (TRUNCFW x) @@ -961,7 +961,7 @@ func rewriteValueMIPS64_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool { +func rewriteValueMIPS64_OpCvt32Fto64_0(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (TRUNCFV x) @@ -972,7 +972,7 @@ func rewriteValueMIPS64_OpCvt32Fto64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool { +func rewriteValueMIPS64_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (MOVFD x) @@ -983,7 +983,7 @@ func rewriteValueMIPS64_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool { +func rewriteValueMIPS64_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (MOVWF x) @@ -994,7 +994,7 @@ func rewriteValueMIPS64_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool { +func rewriteValueMIPS64_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (MOVWD x) @@ -1005,7 +1005,7 @@ func rewriteValueMIPS64_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool { +func rewriteValueMIPS64_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (TRUNCDW x) @@ -1016,7 +1016,7 @@ func rewriteValueMIPS64_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool { +func rewriteValueMIPS64_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (MOVDF x) @@ -1027,7 +1027,7 @@ func rewriteValueMIPS64_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool { +func rewriteValueMIPS64_OpCvt64Fto64_0(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (TRUNCDV x) @@ -1038,7 +1038,7 @@ func rewriteValueMIPS64_OpCvt64Fto64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool { +func rewriteValueMIPS64_OpCvt64to32F_0(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (MOVVF x) @@ -1049,7 +1049,7 @@ func rewriteValueMIPS64_OpCvt64to32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool { +func rewriteValueMIPS64_OpCvt64to64F_0(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (MOVVD x) @@ -1060,7 +1060,7 @@ func rewriteValueMIPS64_OpCvt64to64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv16(v *Value) bool { +func rewriteValueMIPS64_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1083,7 +1083,7 @@ func rewriteValueMIPS64_OpDiv16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv16u(v *Value) bool { +func rewriteValueMIPS64_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1106,7 +1106,7 @@ func rewriteValueMIPS64_OpDiv16u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv32(v *Value) bool { +func rewriteValueMIPS64_OpDiv32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1129,7 +1129,7 @@ func rewriteValueMIPS64_OpDiv32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv32F(v *Value) bool { +func rewriteValueMIPS64_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (DIVF x y) @@ -1142,7 +1142,7 @@ func rewriteValueMIPS64_OpDiv32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv32u(v *Value) bool { +func rewriteValueMIPS64_OpDiv32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1165,7 +1165,7 @@ func rewriteValueMIPS64_OpDiv32u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv64(v *Value) bool { +func rewriteValueMIPS64_OpDiv64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1184,7 +1184,7 @@ func rewriteValueMIPS64_OpDiv64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv64F(v *Value) bool { +func rewriteValueMIPS64_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (DIVD x y) @@ -1197,7 +1197,7 @@ func rewriteValueMIPS64_OpDiv64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv64u(v *Value) bool { +func rewriteValueMIPS64_OpDiv64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1216,7 +1216,7 @@ func rewriteValueMIPS64_OpDiv64u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv8(v *Value) bool { +func rewriteValueMIPS64_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1239,7 +1239,7 @@ func rewriteValueMIPS64_OpDiv8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpDiv8u(v *Value) bool { +func rewriteValueMIPS64_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1262,7 +1262,7 @@ func rewriteValueMIPS64_OpDiv8u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq16(v *Value) bool { +func rewriteValueMIPS64_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1288,7 +1288,7 @@ func rewriteValueMIPS64_OpEq16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq32(v *Value) bool { +func rewriteValueMIPS64_OpEq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1314,7 +1314,7 @@ func rewriteValueMIPS64_OpEq32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq32F(v *Value) bool { +func rewriteValueMIPS64_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1331,7 +1331,7 @@ func rewriteValueMIPS64_OpEq32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq64(v *Value) bool { +func rewriteValueMIPS64_OpEq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1353,7 +1353,7 @@ func rewriteValueMIPS64_OpEq64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq64F(v *Value) bool { +func rewriteValueMIPS64_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1370,7 +1370,7 @@ func rewriteValueMIPS64_OpEq64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEq8(v *Value) bool { +func rewriteValueMIPS64_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1396,7 +1396,7 @@ func rewriteValueMIPS64_OpEq8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEqB(v *Value) bool { +func rewriteValueMIPS64_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1418,7 +1418,7 @@ func rewriteValueMIPS64_OpEqB(v *Value) bool { return true } } -func rewriteValueMIPS64_OpEqPtr(v *Value) bool { +func rewriteValueMIPS64_OpEqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1440,7 +1440,7 @@ func rewriteValueMIPS64_OpEqPtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq16(v *Value) bool { +func rewriteValueMIPS64_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1466,7 +1466,7 @@ func rewriteValueMIPS64_OpGeq16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq16U(v *Value) bool { +func rewriteValueMIPS64_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1492,7 +1492,7 @@ func rewriteValueMIPS64_OpGeq16U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq32(v *Value) bool { +func rewriteValueMIPS64_OpGeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1518,7 +1518,7 @@ func rewriteValueMIPS64_OpGeq32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq32F(v *Value) bool { +func rewriteValueMIPS64_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1535,7 +1535,7 @@ func rewriteValueMIPS64_OpGeq32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq32U(v *Value) bool { +func rewriteValueMIPS64_OpGeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1561,7 +1561,7 @@ func rewriteValueMIPS64_OpGeq32U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq64(v *Value) bool { +func rewriteValueMIPS64_OpGeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1583,7 +1583,7 @@ func rewriteValueMIPS64_OpGeq64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq64F(v *Value) bool { +func rewriteValueMIPS64_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1600,7 +1600,7 @@ func rewriteValueMIPS64_OpGeq64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq64U(v *Value) bool { +func rewriteValueMIPS64_OpGeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1622,7 +1622,7 @@ func rewriteValueMIPS64_OpGeq64U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq8(v *Value) bool { +func rewriteValueMIPS64_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1648,7 +1648,7 @@ func rewriteValueMIPS64_OpGeq8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGeq8U(v *Value) bool { +func rewriteValueMIPS64_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1674,7 +1674,7 @@ func rewriteValueMIPS64_OpGeq8U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool { +func rewriteValueMIPS64_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1683,7 +1683,7 @@ func rewriteValueMIPS64_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater16(v *Value) bool { +func rewriteValueMIPS64_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1704,7 +1704,7 @@ func rewriteValueMIPS64_OpGreater16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater16U(v *Value) bool { +func rewriteValueMIPS64_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1725,7 +1725,7 @@ func rewriteValueMIPS64_OpGreater16U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater32(v *Value) bool { +func rewriteValueMIPS64_OpGreater32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1746,7 +1746,7 @@ func rewriteValueMIPS64_OpGreater32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater32F(v *Value) bool { +func rewriteValueMIPS64_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1763,7 +1763,7 @@ func rewriteValueMIPS64_OpGreater32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater32U(v *Value) bool { +func rewriteValueMIPS64_OpGreater32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1784,7 +1784,7 @@ func rewriteValueMIPS64_OpGreater32U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater64(v *Value) bool { +func rewriteValueMIPS64_OpGreater64_0(v *Value) bool { // match: (Greater64 x y) // cond: // result: (SGT x y) @@ -1797,7 +1797,7 @@ func rewriteValueMIPS64_OpGreater64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater64F(v *Value) bool { +func rewriteValueMIPS64_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -1814,7 +1814,7 @@ func rewriteValueMIPS64_OpGreater64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater64U(v *Value) bool { +func rewriteValueMIPS64_OpGreater64U_0(v *Value) bool { // match: (Greater64U x y) // cond: // result: (SGTU x y) @@ -1827,7 +1827,7 @@ func rewriteValueMIPS64_OpGreater64U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater8(v *Value) bool { +func rewriteValueMIPS64_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1848,7 +1848,7 @@ func rewriteValueMIPS64_OpGreater8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpGreater8U(v *Value) bool { +func rewriteValueMIPS64_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1869,7 +1869,7 @@ func rewriteValueMIPS64_OpGreater8U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpHmul32(v *Value) bool { +func rewriteValueMIPS64_OpHmul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1895,7 +1895,7 @@ func rewriteValueMIPS64_OpHmul32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpHmul32u(v *Value) bool { +func rewriteValueMIPS64_OpHmul32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1921,7 +1921,7 @@ func rewriteValueMIPS64_OpHmul32u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpHmul64(v *Value) bool { +func rewriteValueMIPS64_OpHmul64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1940,7 +1940,7 @@ func rewriteValueMIPS64_OpHmul64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpHmul64u(v *Value) bool { +func rewriteValueMIPS64_OpHmul64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1959,7 +1959,7 @@ func rewriteValueMIPS64_OpHmul64u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpInterCall(v *Value) bool { +func rewriteValueMIPS64_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -1974,7 +1974,7 @@ func rewriteValueMIPS64_OpInterCall(v *Value) bool { return true } } -func rewriteValueMIPS64_OpIsInBounds(v *Value) bool { +func rewriteValueMIPS64_OpIsInBounds_0(v *Value) bool { // match: (IsInBounds idx len) // cond: // result: (SGTU len idx) @@ -1987,7 +1987,7 @@ func rewriteValueMIPS64_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueMIPS64_OpIsNonNil(v *Value) bool { +func rewriteValueMIPS64_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2005,7 +2005,7 @@ func rewriteValueMIPS64_OpIsNonNil(v *Value) bool { return true } } -func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool { +func rewriteValueMIPS64_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2027,7 +2027,7 @@ func rewriteValueMIPS64_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq16(v *Value) bool { +func rewriteValueMIPS64_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2053,7 +2053,7 @@ func rewriteValueMIPS64_OpLeq16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq16U(v *Value) bool { +func rewriteValueMIPS64_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2079,7 +2079,7 @@ func rewriteValueMIPS64_OpLeq16U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq32(v *Value) bool { +func rewriteValueMIPS64_OpLeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2105,7 +2105,7 @@ func rewriteValueMIPS64_OpLeq32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq32F(v *Value) bool { +func rewriteValueMIPS64_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2122,7 +2122,7 @@ func rewriteValueMIPS64_OpLeq32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq32U(v *Value) bool { +func rewriteValueMIPS64_OpLeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2148,7 +2148,7 @@ func rewriteValueMIPS64_OpLeq32U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq64(v *Value) bool { +func rewriteValueMIPS64_OpLeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2170,7 +2170,7 @@ func rewriteValueMIPS64_OpLeq64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq64F(v *Value) bool { +func rewriteValueMIPS64_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2187,7 +2187,7 @@ func rewriteValueMIPS64_OpLeq64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq64U(v *Value) bool { +func rewriteValueMIPS64_OpLeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2209,7 +2209,7 @@ func rewriteValueMIPS64_OpLeq64U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq8(v *Value) bool { +func rewriteValueMIPS64_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2235,7 +2235,7 @@ func rewriteValueMIPS64_OpLeq8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLeq8U(v *Value) bool { +func rewriteValueMIPS64_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2261,7 +2261,7 @@ func rewriteValueMIPS64_OpLeq8U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess16(v *Value) bool { +func rewriteValueMIPS64_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2282,7 +2282,7 @@ func rewriteValueMIPS64_OpLess16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess16U(v *Value) bool { +func rewriteValueMIPS64_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2303,7 +2303,7 @@ func rewriteValueMIPS64_OpLess16U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess32(v *Value) bool { +func rewriteValueMIPS64_OpLess32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2324,7 +2324,7 @@ func rewriteValueMIPS64_OpLess32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess32F(v *Value) bool { +func rewriteValueMIPS64_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2341,7 +2341,7 @@ func rewriteValueMIPS64_OpLess32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess32U(v *Value) bool { +func rewriteValueMIPS64_OpLess32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2362,7 +2362,7 @@ func rewriteValueMIPS64_OpLess32U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess64(v *Value) bool { +func rewriteValueMIPS64_OpLess64_0(v *Value) bool { // match: (Less64 x y) // cond: // result: (SGT y x) @@ -2375,7 +2375,7 @@ func rewriteValueMIPS64_OpLess64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess64F(v *Value) bool { +func rewriteValueMIPS64_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2392,7 +2392,7 @@ func rewriteValueMIPS64_OpLess64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess64U(v *Value) bool { +func rewriteValueMIPS64_OpLess64U_0(v *Value) bool { // match: (Less64U x y) // cond: // result: (SGTU y x) @@ -2405,7 +2405,7 @@ func rewriteValueMIPS64_OpLess64U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess8(v *Value) bool { +func rewriteValueMIPS64_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2426,7 +2426,7 @@ func rewriteValueMIPS64_OpLess8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLess8U(v *Value) bool { +func rewriteValueMIPS64_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2447,7 +2447,7 @@ func rewriteValueMIPS64_OpLess8U(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLoad(v *Value) bool { +func rewriteValueMIPS64_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: t.IsBoolean() // result: (MOVBUload ptr mem) @@ -2600,7 +2600,7 @@ func rewriteValueMIPS64_OpLoad(v *Value) bool { } return false } -func rewriteValueMIPS64_OpLsh16x16(v *Value) bool { +func rewriteValueMIPS64_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2632,7 +2632,7 @@ func rewriteValueMIPS64_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh16x32(v *Value) bool { +func rewriteValueMIPS64_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2664,7 +2664,7 @@ func rewriteValueMIPS64_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh16x64(v *Value) bool { +func rewriteValueMIPS64_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2692,7 +2692,7 @@ func rewriteValueMIPS64_OpLsh16x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh16x8(v *Value) bool { +func rewriteValueMIPS64_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2724,7 +2724,7 @@ func rewriteValueMIPS64_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh32x16(v *Value) bool { +func rewriteValueMIPS64_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2756,7 +2756,7 @@ func rewriteValueMIPS64_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh32x32(v *Value) bool { +func rewriteValueMIPS64_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2788,7 +2788,7 @@ func rewriteValueMIPS64_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh32x64(v *Value) bool { +func rewriteValueMIPS64_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2816,7 +2816,7 @@ func rewriteValueMIPS64_OpLsh32x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh32x8(v *Value) bool { +func rewriteValueMIPS64_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2848,7 +2848,7 @@ func rewriteValueMIPS64_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh64x16(v *Value) bool { +func rewriteValueMIPS64_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2880,7 +2880,7 @@ func rewriteValueMIPS64_OpLsh64x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh64x32(v *Value) bool { +func rewriteValueMIPS64_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2912,7 +2912,7 @@ func rewriteValueMIPS64_OpLsh64x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh64x64(v *Value) bool { +func rewriteValueMIPS64_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2940,7 +2940,7 @@ func rewriteValueMIPS64_OpLsh64x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh64x8(v *Value) bool { +func rewriteValueMIPS64_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2972,7 +2972,7 @@ func rewriteValueMIPS64_OpLsh64x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh8x16(v *Value) bool { +func rewriteValueMIPS64_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3004,7 +3004,7 @@ func rewriteValueMIPS64_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh8x32(v *Value) bool { +func rewriteValueMIPS64_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3036,7 +3036,7 @@ func rewriteValueMIPS64_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh8x64(v *Value) bool { +func rewriteValueMIPS64_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3064,7 +3064,7 @@ func rewriteValueMIPS64_OpLsh8x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpLsh8x8(v *Value) bool { +func rewriteValueMIPS64_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3096,7 +3096,7 @@ func rewriteValueMIPS64_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64ADDV_0(v *Value) bool { // match: (ADDV x (MOVVconst [c])) // cond: is32Bit(c) // result: (ADDVconst [c] x) @@ -3165,7 +3165,7 @@ func rewriteValueMIPS64_OpMIPS64ADDV(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64ADDVconst_0(v *Value) bool { // match: (ADDVconst [off1] (MOVVaddr [off2] {sym} ptr)) // cond: // result: (MOVVaddr [off1+off2] {sym} ptr) @@ -3251,7 +3251,7 @@ func rewriteValueMIPS64_OpMIPS64ADDVconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64AND_0(v *Value) bool { // match: (AND x (MOVVconst [c])) // cond: is32Bit(c) // result: (ANDconst [c] x) @@ -3303,7 +3303,7 @@ func rewriteValueMIPS64_OpMIPS64AND(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64ANDconst_0(v *Value) bool { // match: (ANDconst [0] _) // cond: // result: (MOVVconst [0]) @@ -3360,7 +3360,7 @@ func rewriteValueMIPS64_OpMIPS64ANDconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBUload_0(v *Value) bool { // match: (MOVBUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBUload [off1+off2] {sym} ptr mem) @@ -3410,7 +3410,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBUload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBUreg_0(v *Value) bool { // match: (MOVBUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -3450,7 +3450,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBUreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBload_0(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -3500,7 +3500,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBreg_0(v *Value) bool { // match: (MOVBreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -3540,7 +3540,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBstore_0(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVBstore [off1+off2] {sym} ptr val mem) @@ -3742,7 +3742,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVBstorezero_0(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVBstorezero [off1+off2] {sym} ptr mem) @@ -3792,7 +3792,7 @@ func rewriteValueMIPS64_OpMIPS64MOVBstorezero(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVDload_0(v *Value) bool { // match: (MOVDload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVDload [off1+off2] {sym} ptr mem) @@ -3842,7 +3842,7 @@ func rewriteValueMIPS64_OpMIPS64MOVDload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -3896,7 +3896,7 @@ func rewriteValueMIPS64_OpMIPS64MOVDstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVFload_0(v *Value) bool { // match: (MOVFload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVFload [off1+off2] {sym} ptr mem) @@ -3946,7 +3946,7 @@ func rewriteValueMIPS64_OpMIPS64MOVFload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVFstore_0(v *Value) bool { // match: (MOVFstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVFstore [off1+off2] {sym} ptr val mem) @@ -4000,7 +4000,7 @@ func rewriteValueMIPS64_OpMIPS64MOVFstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHUload_0(v *Value) bool { // match: (MOVHUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHUload [off1+off2] {sym} ptr mem) @@ -4050,7 +4050,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHUload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHUreg_0(v *Value) bool { // match: (MOVHUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -4114,7 +4114,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHUreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -4164,7 +4164,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHreg_0(v *Value) bool { // match: (MOVHreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -4252,7 +4252,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHstore_0(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVHstore [off1+off2] {sym} ptr val mem) @@ -4412,7 +4412,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVHstorezero_0(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVHstorezero [off1+off2] {sym} ptr mem) @@ -4462,7 +4462,7 @@ func rewriteValueMIPS64_OpMIPS64MOVHstorezero(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVVload_0(v *Value) bool { // match: (MOVVload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVVload [off1+off2] {sym} ptr mem) @@ -4512,7 +4512,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVVreg_0(v *Value) bool { // match: (MOVVreg x) // cond: x.Uses == 1 // result: (MOVVnop x) @@ -4540,7 +4540,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVVstore_0(v *Value) bool { // match: (MOVVstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVVstore [off1+off2] {sym} ptr val mem) @@ -4616,7 +4616,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVVstorezero_0(v *Value) bool { // match: (MOVVstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVVstorezero [off1+off2] {sym} ptr mem) @@ -4666,7 +4666,7 @@ func rewriteValueMIPS64_OpMIPS64MOVVstorezero(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWUload_0(v *Value) bool { // match: (MOVWUload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWUload [off1+off2] {sym} ptr mem) @@ -4716,7 +4716,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWUload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWUreg_0(v *Value) bool { // match: (MOVWUreg x:(MOVBUload _ _)) // cond: // result: (MOVVreg x) @@ -4804,7 +4804,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWUreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWload_0(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -4854,7 +4854,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWload(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWreg_0(v *Value) bool { // match: (MOVWreg x:(MOVBload _ _)) // cond: // result: (MOVVreg x) @@ -4975,6 +4975,9 @@ func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueMIPS64_OpMIPS64MOVWreg_10(v *Value) bool { // match: (MOVWreg (MOVVconst [c])) // cond: // result: (MOVVconst [int64(int32(c))]) @@ -4990,7 +4993,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWreg(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWstore_0(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDVconst [off2] ptr) val mem) // cond: is32Bit(off1+off2) // result: (MOVWstore [off1+off2] {sym} ptr val mem) @@ -5108,7 +5111,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWstore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64MOVWstorezero_0(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDVconst [off2] ptr) mem) // cond: is32Bit(off1+off2) // result: (MOVWstorezero [off1+off2] {sym} ptr mem) @@ -5158,7 +5161,7 @@ func rewriteValueMIPS64_OpMIPS64MOVWstorezero(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64NEGV_0(v *Value) bool { // match: (NEGV (MOVVconst [c])) // cond: // result: (MOVVconst [-c]) @@ -5174,7 +5177,7 @@ func rewriteValueMIPS64_OpMIPS64NEGV(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64NOR_0(v *Value) bool { // match: (NOR x (MOVVconst [c])) // cond: is32Bit(c) // result: (NORconst [c] x) @@ -5213,7 +5216,7 @@ func rewriteValueMIPS64_OpMIPS64NOR(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64NORconst_0(v *Value) bool { // match: (NORconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [^(c|d)]) @@ -5230,7 +5233,7 @@ func rewriteValueMIPS64_OpMIPS64NORconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64OR_0(v *Value) bool { // match: (OR x (MOVVconst [c])) // cond: is32Bit(c) // result: (ORconst [c] x) @@ -5282,7 +5285,7 @@ func rewriteValueMIPS64_OpMIPS64OR(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64ORconst_0(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -5342,7 +5345,7 @@ func rewriteValueMIPS64_OpMIPS64ORconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SGT_0(v *Value) bool { // match: (SGT (MOVVconst [c]) x) // cond: is32Bit(c) // result: (SGTconst [c] x) @@ -5363,7 +5366,7 @@ func rewriteValueMIPS64_OpMIPS64SGT(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SGTU_0(v *Value) bool { // match: (SGTU (MOVVconst [c]) x) // cond: is32Bit(c) // result: (SGTUconst [c] x) @@ -5384,7 +5387,7 @@ func rewriteValueMIPS64_OpMIPS64SGTU(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SGTUconst_0(v *Value) bool { // match: (SGTUconst [c] (MOVVconst [d])) // cond: uint64(c)>uint64(d) // result: (MOVVconst [1]) @@ -5487,7 +5490,7 @@ func rewriteValueMIPS64_OpMIPS64SGTUconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SGTconst_0(v *Value) bool { // match: (SGTconst [c] (MOVVconst [d])) // cond: int64(c)>int64(d) // result: (MOVVconst [1]) @@ -5650,6 +5653,9 @@ func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool { v.AuxInt = 0 return true } + return false +} +func rewriteValueMIPS64_OpMIPS64SGTconst_10(v *Value) bool { // match: (SGTconst [c] (MOVWUreg _)) // cond: int64(c) < 0 // result: (MOVVconst [0]) @@ -5702,7 +5708,7 @@ func rewriteValueMIPS64_OpMIPS64SGTconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SLLV_0(v *Value) bool { // match: (SLLV _ (MOVVconst [c])) // cond: uint64(c)>=64 // result: (MOVVconst [0]) @@ -5736,7 +5742,7 @@ func rewriteValueMIPS64_OpMIPS64SLLV(v *Value) bool { } 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)<=64 // result: (SRAVconst x [63]) @@ -5789,7 +5795,7 @@ func rewriteValueMIPS64_OpMIPS64SRAV(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SRAVconst_0(v *Value) bool { // match: (SRAVconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [int64(d)>>uint64(c)]) @@ -5806,7 +5812,7 @@ func rewriteValueMIPS64_OpMIPS64SRAVconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SRLV_0(v *Value) bool { // match: (SRLV _ (MOVVconst [c])) // cond: uint64(c)>=64 // result: (MOVVconst [0]) @@ -5840,7 +5846,7 @@ func rewriteValueMIPS64_OpMIPS64SRLV(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SRLVconst_0(v *Value) bool { // match: (SRLVconst [c] (MOVVconst [d])) // cond: // result: (MOVVconst [int64(uint64(d)>>uint64(c))]) @@ -5857,7 +5863,7 @@ func rewriteValueMIPS64_OpMIPS64SRLVconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SUBV_0(v *Value) bool { // match: (SUBV x (MOVVconst [c])) // cond: is32Bit(c) // result: (SUBVconst [c] x) @@ -5906,7 +5912,7 @@ func rewriteValueMIPS64_OpMIPS64SUBV(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64SUBVconst_0(v *Value) bool { // match: (SUBVconst [0] x) // cond: // result: x @@ -5974,7 +5980,7 @@ func rewriteValueMIPS64_OpMIPS64SUBVconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64XOR_0(v *Value) bool { // match: (XOR x (MOVVconst [c])) // cond: is32Bit(c) // result: (XORconst [c] x) @@ -6025,7 +6031,7 @@ func rewriteValueMIPS64_OpMIPS64XOR(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool { +func rewriteValueMIPS64_OpMIPS64XORconst_0(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -6087,7 +6093,7 @@ func rewriteValueMIPS64_OpMIPS64XORconst(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMod16(v *Value) bool { +func rewriteValueMIPS64_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6110,7 +6116,7 @@ func rewriteValueMIPS64_OpMod16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod16u(v *Value) bool { +func rewriteValueMIPS64_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6133,7 +6139,7 @@ func rewriteValueMIPS64_OpMod16u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod32(v *Value) bool { +func rewriteValueMIPS64_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6156,7 +6162,7 @@ func rewriteValueMIPS64_OpMod32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod32u(v *Value) bool { +func rewriteValueMIPS64_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6179,7 +6185,7 @@ func rewriteValueMIPS64_OpMod32u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod64(v *Value) bool { +func rewriteValueMIPS64_OpMod64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6198,7 +6204,7 @@ func rewriteValueMIPS64_OpMod64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod64u(v *Value) bool { +func rewriteValueMIPS64_OpMod64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6217,7 +6223,7 @@ func rewriteValueMIPS64_OpMod64u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod8(v *Value) bool { +func rewriteValueMIPS64_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6240,7 +6246,7 @@ func rewriteValueMIPS64_OpMod8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMod8u(v *Value) bool { +func rewriteValueMIPS64_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6263,11 +6269,9 @@ func rewriteValueMIPS64_OpMod8u(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMove(v *Value) bool { +func rewriteValueMIPS64_OpMove_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Move [0] _ _ mem) @@ -6559,6 +6563,15 @@ func rewriteValueMIPS64_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueMIPS64_OpMove_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Move [3] dst src mem) // cond: // result: (MOVBstore [2] dst (MOVBload [2] src mem) (MOVBstore [1] dst (MOVBload [1] src mem) (MOVBstore dst (MOVBload src mem) mem))) @@ -6776,7 +6789,7 @@ func rewriteValueMIPS64_OpMove(v *Value) bool { } return false } -func rewriteValueMIPS64_OpMul16(v *Value) bool { +func rewriteValueMIPS64_OpMul16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6795,7 +6808,7 @@ func rewriteValueMIPS64_OpMul16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMul32(v *Value) bool { +func rewriteValueMIPS64_OpMul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6814,7 +6827,7 @@ func rewriteValueMIPS64_OpMul32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMul32F(v *Value) bool { +func rewriteValueMIPS64_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (MULF x y) @@ -6827,7 +6840,7 @@ func rewriteValueMIPS64_OpMul32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMul64(v *Value) bool { +func rewriteValueMIPS64_OpMul64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6846,7 +6859,7 @@ func rewriteValueMIPS64_OpMul64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMul64F(v *Value) bool { +func rewriteValueMIPS64_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (MULD x y) @@ -6859,7 +6872,7 @@ func rewriteValueMIPS64_OpMul64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpMul8(v *Value) bool { +func rewriteValueMIPS64_OpMul8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6878,7 +6891,7 @@ func rewriteValueMIPS64_OpMul8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg16(v *Value) bool { +func rewriteValueMIPS64_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEGV x) @@ -6889,7 +6902,7 @@ func rewriteValueMIPS64_OpNeg16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg32(v *Value) bool { +func rewriteValueMIPS64_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGV x) @@ -6900,7 +6913,7 @@ func rewriteValueMIPS64_OpNeg32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg32F(v *Value) bool { +func rewriteValueMIPS64_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (NEGF x) @@ -6911,7 +6924,7 @@ func rewriteValueMIPS64_OpNeg32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg64(v *Value) bool { +func rewriteValueMIPS64_OpNeg64_0(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEGV x) @@ -6922,7 +6935,7 @@ func rewriteValueMIPS64_OpNeg64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg64F(v *Value) bool { +func rewriteValueMIPS64_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (NEGD x) @@ -6933,7 +6946,7 @@ func rewriteValueMIPS64_OpNeg64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeg8(v *Value) bool { +func rewriteValueMIPS64_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEGV x) @@ -6944,7 +6957,7 @@ func rewriteValueMIPS64_OpNeg8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq16(v *Value) bool { +func rewriteValueMIPS64_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6970,7 +6983,7 @@ func rewriteValueMIPS64_OpNeq16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq32(v *Value) bool { +func rewriteValueMIPS64_OpNeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6996,7 +7009,7 @@ func rewriteValueMIPS64_OpNeq32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq32F(v *Value) bool { +func rewriteValueMIPS64_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -7013,7 +7026,7 @@ func rewriteValueMIPS64_OpNeq32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq64(v *Value) bool { +func rewriteValueMIPS64_OpNeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7035,7 +7048,7 @@ func rewriteValueMIPS64_OpNeq64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq64F(v *Value) bool { +func rewriteValueMIPS64_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -7052,7 +7065,7 @@ func rewriteValueMIPS64_OpNeq64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeq8(v *Value) bool { +func rewriteValueMIPS64_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7078,7 +7091,7 @@ func rewriteValueMIPS64_OpNeq8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeqB(v *Value) bool { +func rewriteValueMIPS64_OpNeqB_0(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -7091,7 +7104,7 @@ func rewriteValueMIPS64_OpNeqB(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNeqPtr(v *Value) bool { +func rewriteValueMIPS64_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7113,7 +7126,7 @@ func rewriteValueMIPS64_OpNeqPtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNilCheck(v *Value) bool { +func rewriteValueMIPS64_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -7126,7 +7139,7 @@ func rewriteValueMIPS64_OpNilCheck(v *Value) bool { return true } } -func rewriteValueMIPS64_OpNot(v *Value) bool { +func rewriteValueMIPS64_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -7138,7 +7151,7 @@ func rewriteValueMIPS64_OpNot(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOffPtr(v *Value) bool { +func rewriteValueMIPS64_OpOffPtr_0(v *Value) bool { // match: (OffPtr [off] ptr:(SP)) // cond: // result: (MOVVaddr [off] ptr) @@ -7165,7 +7178,7 @@ func rewriteValueMIPS64_OpOffPtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOr16(v *Value) bool { +func rewriteValueMIPS64_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -7178,7 +7191,7 @@ func rewriteValueMIPS64_OpOr16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOr32(v *Value) bool { +func rewriteValueMIPS64_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -7191,7 +7204,7 @@ func rewriteValueMIPS64_OpOr32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOr64(v *Value) bool { +func rewriteValueMIPS64_OpOr64_0(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -7204,7 +7217,7 @@ func rewriteValueMIPS64_OpOr64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOr8(v *Value) bool { +func rewriteValueMIPS64_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -7217,7 +7230,7 @@ func rewriteValueMIPS64_OpOr8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpOrB(v *Value) bool { +func rewriteValueMIPS64_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -7230,7 +7243,7 @@ func rewriteValueMIPS64_OpOrB(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRound32F(v *Value) bool { +func rewriteValueMIPS64_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: x @@ -7242,7 +7255,7 @@ func rewriteValueMIPS64_OpRound32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRound64F(v *Value) bool { +func rewriteValueMIPS64_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: x @@ -7254,7 +7267,7 @@ func rewriteValueMIPS64_OpRound64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool { +func rewriteValueMIPS64_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7288,7 +7301,7 @@ func rewriteValueMIPS64_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool { +func rewriteValueMIPS64_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7322,7 +7335,7 @@ func rewriteValueMIPS64_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool { +func rewriteValueMIPS64_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7352,7 +7365,7 @@ func rewriteValueMIPS64_OpRsh16Ux64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool { +func rewriteValueMIPS64_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7386,7 +7399,7 @@ func rewriteValueMIPS64_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16x16(v *Value) bool { +func rewriteValueMIPS64_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7420,7 +7433,7 @@ func rewriteValueMIPS64_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16x32(v *Value) bool { +func rewriteValueMIPS64_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7454,7 +7467,7 @@ func rewriteValueMIPS64_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16x64(v *Value) bool { +func rewriteValueMIPS64_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7484,7 +7497,7 @@ func rewriteValueMIPS64_OpRsh16x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh16x8(v *Value) bool { +func rewriteValueMIPS64_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7518,7 +7531,7 @@ func rewriteValueMIPS64_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool { +func rewriteValueMIPS64_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7552,7 +7565,7 @@ func rewriteValueMIPS64_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool { +func rewriteValueMIPS64_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7586,7 +7599,7 @@ func rewriteValueMIPS64_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool { +func rewriteValueMIPS64_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7616,7 +7629,7 @@ func rewriteValueMIPS64_OpRsh32Ux64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool { +func rewriteValueMIPS64_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7650,7 +7663,7 @@ func rewriteValueMIPS64_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32x16(v *Value) bool { +func rewriteValueMIPS64_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7684,7 +7697,7 @@ func rewriteValueMIPS64_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32x32(v *Value) bool { +func rewriteValueMIPS64_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7718,7 +7731,7 @@ func rewriteValueMIPS64_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32x64(v *Value) bool { +func rewriteValueMIPS64_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7748,7 +7761,7 @@ func rewriteValueMIPS64_OpRsh32x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh32x8(v *Value) bool { +func rewriteValueMIPS64_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7782,7 +7795,7 @@ func rewriteValueMIPS64_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool { +func rewriteValueMIPS64_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7814,7 +7827,7 @@ func rewriteValueMIPS64_OpRsh64Ux16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool { +func rewriteValueMIPS64_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7846,7 +7859,7 @@ func rewriteValueMIPS64_OpRsh64Ux32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool { +func rewriteValueMIPS64_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7874,7 +7887,7 @@ func rewriteValueMIPS64_OpRsh64Ux64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool { +func rewriteValueMIPS64_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7906,7 +7919,7 @@ func rewriteValueMIPS64_OpRsh64Ux8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64x16(v *Value) bool { +func rewriteValueMIPS64_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7938,7 +7951,7 @@ func rewriteValueMIPS64_OpRsh64x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64x32(v *Value) bool { +func rewriteValueMIPS64_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7970,7 +7983,7 @@ func rewriteValueMIPS64_OpRsh64x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64x64(v *Value) bool { +func rewriteValueMIPS64_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7998,7 +8011,7 @@ func rewriteValueMIPS64_OpRsh64x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh64x8(v *Value) bool { +func rewriteValueMIPS64_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8030,7 +8043,7 @@ func rewriteValueMIPS64_OpRsh64x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool { +func rewriteValueMIPS64_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8064,7 +8077,7 @@ func rewriteValueMIPS64_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool { +func rewriteValueMIPS64_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8098,7 +8111,7 @@ func rewriteValueMIPS64_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool { +func rewriteValueMIPS64_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8128,7 +8141,7 @@ func rewriteValueMIPS64_OpRsh8Ux64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool { +func rewriteValueMIPS64_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8162,7 +8175,7 @@ func rewriteValueMIPS64_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8x16(v *Value) bool { +func rewriteValueMIPS64_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8196,7 +8209,7 @@ func rewriteValueMIPS64_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8x32(v *Value) bool { +func rewriteValueMIPS64_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8230,7 +8243,7 @@ func rewriteValueMIPS64_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8x64(v *Value) bool { +func rewriteValueMIPS64_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8260,7 +8273,7 @@ func rewriteValueMIPS64_OpRsh8x64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpRsh8x8(v *Value) bool { +func rewriteValueMIPS64_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8294,7 +8307,7 @@ func rewriteValueMIPS64_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSelect0(v *Value) bool { +func rewriteValueMIPS64_OpSelect0_0(v *Value) bool { // match: (Select0 (DIVVU _ (MOVVconst [1]))) // cond: // result: (MOVVconst [0]) @@ -8382,7 +8395,7 @@ func rewriteValueMIPS64_OpSelect0(v *Value) bool { } return false } -func rewriteValueMIPS64_OpSelect1(v *Value) bool { +func rewriteValueMIPS64_OpSelect1_0(v *Value) bool { // match: (Select1 (MULVU x (MOVVconst [-1]))) // cond: // result: (NEGV x) @@ -8587,6 +8600,9 @@ func rewriteValueMIPS64_OpSelect1(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueMIPS64_OpSelect1_10(v *Value) bool { // match: (Select1 (MULVU (MOVVconst [0]) _)) // cond: // result: (MOVVconst [0]) @@ -8798,6 +8814,9 @@ func rewriteValueMIPS64_OpSelect1(v *Value) bool { v.AuxInt = c * d return true } + return false +} +func rewriteValueMIPS64_OpSelect1_20(v *Value) bool { // match: (Select1 (DIVV (MOVVconst [c]) (MOVVconst [d]))) // cond: // result: (MOVVconst [int64(c)/int64(d)]) @@ -8844,7 +8863,7 @@ func rewriteValueMIPS64_OpSelect1(v *Value) bool { } return false } -func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool { +func rewriteValueMIPS64_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -8855,7 +8874,7 @@ func rewriteValueMIPS64_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool { +func rewriteValueMIPS64_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -8866,7 +8885,7 @@ func rewriteValueMIPS64_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool { +func rewriteValueMIPS64_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -8877,7 +8896,7 @@ func rewriteValueMIPS64_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool { +func rewriteValueMIPS64_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -8888,7 +8907,7 @@ func rewriteValueMIPS64_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool { +func rewriteValueMIPS64_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -8899,7 +8918,7 @@ func rewriteValueMIPS64_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool { +func rewriteValueMIPS64_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -8910,7 +8929,7 @@ func rewriteValueMIPS64_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSlicemask(v *Value) bool { +func rewriteValueMIPS64_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -8927,7 +8946,7 @@ func rewriteValueMIPS64_OpSlicemask(v *Value) bool { return true } } -func rewriteValueMIPS64_OpStaticCall(v *Value) bool { +func rewriteValueMIPS64_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -8942,7 +8961,7 @@ func rewriteValueMIPS64_OpStaticCall(v *Value) bool { return true } } -func rewriteValueMIPS64_OpStore(v *Value) bool { +func rewriteValueMIPS64_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 1 // result: (MOVBstore ptr val mem) @@ -9047,7 +9066,7 @@ func rewriteValueMIPS64_OpStore(v *Value) bool { } return false } -func rewriteValueMIPS64_OpSub16(v *Value) bool { +func rewriteValueMIPS64_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBV x y) @@ -9060,7 +9079,7 @@ func rewriteValueMIPS64_OpSub16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSub32(v *Value) bool { +func rewriteValueMIPS64_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBV x y) @@ -9073,7 +9092,7 @@ func rewriteValueMIPS64_OpSub32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSub32F(v *Value) bool { +func rewriteValueMIPS64_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (SUBF x y) @@ -9086,7 +9105,7 @@ func rewriteValueMIPS64_OpSub32F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSub64(v *Value) bool { +func rewriteValueMIPS64_OpSub64_0(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUBV x y) @@ -9099,7 +9118,7 @@ func rewriteValueMIPS64_OpSub64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSub64F(v *Value) bool { +func rewriteValueMIPS64_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (SUBD x y) @@ -9112,7 +9131,7 @@ func rewriteValueMIPS64_OpSub64F(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSub8(v *Value) bool { +func rewriteValueMIPS64_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBV x y) @@ -9125,7 +9144,7 @@ func rewriteValueMIPS64_OpSub8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpSubPtr(v *Value) bool { +func rewriteValueMIPS64_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUBV x y) @@ -9138,7 +9157,7 @@ func rewriteValueMIPS64_OpSubPtr(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool { +func rewriteValueMIPS64_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -9150,7 +9169,7 @@ func rewriteValueMIPS64_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool { +func rewriteValueMIPS64_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -9162,7 +9181,7 @@ func rewriteValueMIPS64_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool { +func rewriteValueMIPS64_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -9174,7 +9193,7 @@ func rewriteValueMIPS64_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool { +func rewriteValueMIPS64_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -9186,7 +9205,7 @@ func rewriteValueMIPS64_OpTrunc64to16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool { +func rewriteValueMIPS64_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -9198,7 +9217,7 @@ func rewriteValueMIPS64_OpTrunc64to32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool { +func rewriteValueMIPS64_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -9210,7 +9229,7 @@ func rewriteValueMIPS64_OpTrunc64to8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpXor16(v *Value) bool { +func rewriteValueMIPS64_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -9223,7 +9242,7 @@ func rewriteValueMIPS64_OpXor16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpXor32(v *Value) bool { +func rewriteValueMIPS64_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -9236,7 +9255,7 @@ func rewriteValueMIPS64_OpXor32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpXor64(v *Value) bool { +func rewriteValueMIPS64_OpXor64_0(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -9249,7 +9268,7 @@ func rewriteValueMIPS64_OpXor64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpXor8(v *Value) bool { +func rewriteValueMIPS64_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -9262,11 +9281,9 @@ func rewriteValueMIPS64_OpXor8(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZero(v *Value) bool { +func rewriteValueMIPS64_OpZero_0(v *Value) bool { b := v.Block _ = b - config := b.Func.Config - _ = config types := &b.Func.Config.Types _ = types // match: (Zero [0] _ mem) @@ -9527,6 +9544,15 @@ func rewriteValueMIPS64_OpZero(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueMIPS64_OpZero_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config + types := &b.Func.Config.Types + _ = types // match: (Zero [3] ptr mem) // cond: // result: (MOVBstore [2] ptr (MOVVconst [0]) (MOVBstore [1] ptr (MOVVconst [0]) (MOVBstore [0] ptr (MOVVconst [0]) mem))) @@ -9736,7 +9762,7 @@ func rewriteValueMIPS64_OpZero(v *Value) bool { } return false } -func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHUreg x) @@ -9747,7 +9773,7 @@ func rewriteValueMIPS64_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHUreg x) @@ -9758,7 +9784,7 @@ func rewriteValueMIPS64_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWUreg x) @@ -9769,7 +9795,7 @@ func rewriteValueMIPS64_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBUreg x) @@ -9780,7 +9806,7 @@ func rewriteValueMIPS64_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBUreg x) @@ -9791,7 +9817,7 @@ func rewriteValueMIPS64_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueMIPS64_OpZeroExt8to64(v *Value) bool { +func rewriteValueMIPS64_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBUreg x) diff --git a/src/cmd/compile/internal/ssa/rewritePPC64.go b/src/cmd/compile/internal/ssa/rewritePPC64.go index 878802075a..70f8de1791 100644 --- a/src/cmd/compile/internal/ssa/rewritePPC64.go +++ b/src/cmd/compile/internal/ssa/rewritePPC64.go @@ -14,595 +14,595 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValuePPC64(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValuePPC64_OpAdd16(v) + return rewriteValuePPC64_OpAdd16_0(v) case OpAdd32: - return rewriteValuePPC64_OpAdd32(v) + return rewriteValuePPC64_OpAdd32_0(v) case OpAdd32F: - return rewriteValuePPC64_OpAdd32F(v) + return rewriteValuePPC64_OpAdd32F_0(v) case OpAdd64: - return rewriteValuePPC64_OpAdd64(v) + return rewriteValuePPC64_OpAdd64_0(v) case OpAdd64F: - return rewriteValuePPC64_OpAdd64F(v) + return rewriteValuePPC64_OpAdd64F_0(v) case OpAdd8: - return rewriteValuePPC64_OpAdd8(v) + return rewriteValuePPC64_OpAdd8_0(v) case OpAddPtr: - return rewriteValuePPC64_OpAddPtr(v) + return rewriteValuePPC64_OpAddPtr_0(v) case OpAddr: - return rewriteValuePPC64_OpAddr(v) + return rewriteValuePPC64_OpAddr_0(v) case OpAnd16: - return rewriteValuePPC64_OpAnd16(v) + return rewriteValuePPC64_OpAnd16_0(v) case OpAnd32: - return rewriteValuePPC64_OpAnd32(v) + return rewriteValuePPC64_OpAnd32_0(v) case OpAnd64: - return rewriteValuePPC64_OpAnd64(v) + return rewriteValuePPC64_OpAnd64_0(v) case OpAnd8: - return rewriteValuePPC64_OpAnd8(v) + return rewriteValuePPC64_OpAnd8_0(v) case OpAndB: - return rewriteValuePPC64_OpAndB(v) + return rewriteValuePPC64_OpAndB_0(v) case OpAtomicAdd32: - return rewriteValuePPC64_OpAtomicAdd32(v) + return rewriteValuePPC64_OpAtomicAdd32_0(v) case OpAtomicAdd64: - return rewriteValuePPC64_OpAtomicAdd64(v) + return rewriteValuePPC64_OpAtomicAdd64_0(v) case OpAtomicAnd8: - return rewriteValuePPC64_OpAtomicAnd8(v) + return rewriteValuePPC64_OpAtomicAnd8_0(v) case OpAtomicCompareAndSwap32: - return rewriteValuePPC64_OpAtomicCompareAndSwap32(v) + return rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v) case OpAtomicCompareAndSwap64: - return rewriteValuePPC64_OpAtomicCompareAndSwap64(v) + return rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v) case OpAtomicExchange32: - return rewriteValuePPC64_OpAtomicExchange32(v) + return rewriteValuePPC64_OpAtomicExchange32_0(v) case OpAtomicExchange64: - return rewriteValuePPC64_OpAtomicExchange64(v) + return rewriteValuePPC64_OpAtomicExchange64_0(v) case OpAtomicLoad32: - return rewriteValuePPC64_OpAtomicLoad32(v) + return rewriteValuePPC64_OpAtomicLoad32_0(v) case OpAtomicLoad64: - return rewriteValuePPC64_OpAtomicLoad64(v) + return rewriteValuePPC64_OpAtomicLoad64_0(v) case OpAtomicLoadPtr: - return rewriteValuePPC64_OpAtomicLoadPtr(v) + return rewriteValuePPC64_OpAtomicLoadPtr_0(v) case OpAtomicOr8: - return rewriteValuePPC64_OpAtomicOr8(v) + return rewriteValuePPC64_OpAtomicOr8_0(v) case OpAtomicStore32: - return rewriteValuePPC64_OpAtomicStore32(v) + return rewriteValuePPC64_OpAtomicStore32_0(v) case OpAtomicStore64: - return rewriteValuePPC64_OpAtomicStore64(v) + return rewriteValuePPC64_OpAtomicStore64_0(v) case OpAvg64u: - return rewriteValuePPC64_OpAvg64u(v) + return rewriteValuePPC64_OpAvg64u_0(v) case OpClosureCall: - return rewriteValuePPC64_OpClosureCall(v) + return rewriteValuePPC64_OpClosureCall_0(v) case OpCom16: - return rewriteValuePPC64_OpCom16(v) + return rewriteValuePPC64_OpCom16_0(v) case OpCom32: - return rewriteValuePPC64_OpCom32(v) + return rewriteValuePPC64_OpCom32_0(v) case OpCom64: - return rewriteValuePPC64_OpCom64(v) + return rewriteValuePPC64_OpCom64_0(v) case OpCom8: - return rewriteValuePPC64_OpCom8(v) + return rewriteValuePPC64_OpCom8_0(v) case OpConst16: - return rewriteValuePPC64_OpConst16(v) + return rewriteValuePPC64_OpConst16_0(v) case OpConst32: - return rewriteValuePPC64_OpConst32(v) + return rewriteValuePPC64_OpConst32_0(v) case OpConst32F: - return rewriteValuePPC64_OpConst32F(v) + return rewriteValuePPC64_OpConst32F_0(v) case OpConst64: - return rewriteValuePPC64_OpConst64(v) + return rewriteValuePPC64_OpConst64_0(v) case OpConst64F: - return rewriteValuePPC64_OpConst64F(v) + return rewriteValuePPC64_OpConst64F_0(v) case OpConst8: - return rewriteValuePPC64_OpConst8(v) + return rewriteValuePPC64_OpConst8_0(v) case OpConstBool: - return rewriteValuePPC64_OpConstBool(v) + return rewriteValuePPC64_OpConstBool_0(v) case OpConstNil: - return rewriteValuePPC64_OpConstNil(v) + return rewriteValuePPC64_OpConstNil_0(v) case OpConvert: - return rewriteValuePPC64_OpConvert(v) + return rewriteValuePPC64_OpConvert_0(v) case OpCvt32Fto32: - return rewriteValuePPC64_OpCvt32Fto32(v) + return rewriteValuePPC64_OpCvt32Fto32_0(v) case OpCvt32Fto64: - return rewriteValuePPC64_OpCvt32Fto64(v) + return rewriteValuePPC64_OpCvt32Fto64_0(v) case OpCvt32Fto64F: - return rewriteValuePPC64_OpCvt32Fto64F(v) + return rewriteValuePPC64_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValuePPC64_OpCvt32to32F(v) + return rewriteValuePPC64_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValuePPC64_OpCvt32to64F(v) + return rewriteValuePPC64_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValuePPC64_OpCvt64Fto32(v) + return rewriteValuePPC64_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValuePPC64_OpCvt64Fto32F(v) + return rewriteValuePPC64_OpCvt64Fto32F_0(v) case OpCvt64Fto64: - return rewriteValuePPC64_OpCvt64Fto64(v) + return rewriteValuePPC64_OpCvt64Fto64_0(v) case OpCvt64to32F: - return rewriteValuePPC64_OpCvt64to32F(v) + return rewriteValuePPC64_OpCvt64to32F_0(v) case OpCvt64to64F: - return rewriteValuePPC64_OpCvt64to64F(v) + return rewriteValuePPC64_OpCvt64to64F_0(v) case OpDiv16: - return rewriteValuePPC64_OpDiv16(v) + return rewriteValuePPC64_OpDiv16_0(v) case OpDiv16u: - return rewriteValuePPC64_OpDiv16u(v) + return rewriteValuePPC64_OpDiv16u_0(v) case OpDiv32: - return rewriteValuePPC64_OpDiv32(v) + return rewriteValuePPC64_OpDiv32_0(v) case OpDiv32F: - return rewriteValuePPC64_OpDiv32F(v) + return rewriteValuePPC64_OpDiv32F_0(v) case OpDiv32u: - return rewriteValuePPC64_OpDiv32u(v) + return rewriteValuePPC64_OpDiv32u_0(v) case OpDiv64: - return rewriteValuePPC64_OpDiv64(v) + return rewriteValuePPC64_OpDiv64_0(v) case OpDiv64F: - return rewriteValuePPC64_OpDiv64F(v) + return rewriteValuePPC64_OpDiv64F_0(v) case OpDiv64u: - return rewriteValuePPC64_OpDiv64u(v) + return rewriteValuePPC64_OpDiv64u_0(v) case OpDiv8: - return rewriteValuePPC64_OpDiv8(v) + return rewriteValuePPC64_OpDiv8_0(v) case OpDiv8u: - return rewriteValuePPC64_OpDiv8u(v) + return rewriteValuePPC64_OpDiv8u_0(v) case OpEq16: - return rewriteValuePPC64_OpEq16(v) + return rewriteValuePPC64_OpEq16_0(v) case OpEq32: - return rewriteValuePPC64_OpEq32(v) + return rewriteValuePPC64_OpEq32_0(v) case OpEq32F: - return rewriteValuePPC64_OpEq32F(v) + return rewriteValuePPC64_OpEq32F_0(v) case OpEq64: - return rewriteValuePPC64_OpEq64(v) + return rewriteValuePPC64_OpEq64_0(v) case OpEq64F: - return rewriteValuePPC64_OpEq64F(v) + return rewriteValuePPC64_OpEq64F_0(v) case OpEq8: - return rewriteValuePPC64_OpEq8(v) + return rewriteValuePPC64_OpEq8_0(v) case OpEqB: - return rewriteValuePPC64_OpEqB(v) + return rewriteValuePPC64_OpEqB_0(v) case OpEqPtr: - return rewriteValuePPC64_OpEqPtr(v) + return rewriteValuePPC64_OpEqPtr_0(v) case OpGeq16: - return rewriteValuePPC64_OpGeq16(v) + return rewriteValuePPC64_OpGeq16_0(v) case OpGeq16U: - return rewriteValuePPC64_OpGeq16U(v) + return rewriteValuePPC64_OpGeq16U_0(v) case OpGeq32: - return rewriteValuePPC64_OpGeq32(v) + return rewriteValuePPC64_OpGeq32_0(v) case OpGeq32F: - return rewriteValuePPC64_OpGeq32F(v) + return rewriteValuePPC64_OpGeq32F_0(v) case OpGeq32U: - return rewriteValuePPC64_OpGeq32U(v) + return rewriteValuePPC64_OpGeq32U_0(v) case OpGeq64: - return rewriteValuePPC64_OpGeq64(v) + return rewriteValuePPC64_OpGeq64_0(v) case OpGeq64F: - return rewriteValuePPC64_OpGeq64F(v) + return rewriteValuePPC64_OpGeq64F_0(v) case OpGeq64U: - return rewriteValuePPC64_OpGeq64U(v) + return rewriteValuePPC64_OpGeq64U_0(v) case OpGeq8: - return rewriteValuePPC64_OpGeq8(v) + return rewriteValuePPC64_OpGeq8_0(v) case OpGeq8U: - return rewriteValuePPC64_OpGeq8U(v) + return rewriteValuePPC64_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValuePPC64_OpGetClosurePtr(v) + return rewriteValuePPC64_OpGetClosurePtr_0(v) case OpGreater16: - return rewriteValuePPC64_OpGreater16(v) + return rewriteValuePPC64_OpGreater16_0(v) case OpGreater16U: - return rewriteValuePPC64_OpGreater16U(v) + return rewriteValuePPC64_OpGreater16U_0(v) case OpGreater32: - return rewriteValuePPC64_OpGreater32(v) + return rewriteValuePPC64_OpGreater32_0(v) case OpGreater32F: - return rewriteValuePPC64_OpGreater32F(v) + return rewriteValuePPC64_OpGreater32F_0(v) case OpGreater32U: - return rewriteValuePPC64_OpGreater32U(v) + return rewriteValuePPC64_OpGreater32U_0(v) case OpGreater64: - return rewriteValuePPC64_OpGreater64(v) + return rewriteValuePPC64_OpGreater64_0(v) case OpGreater64F: - return rewriteValuePPC64_OpGreater64F(v) + return rewriteValuePPC64_OpGreater64F_0(v) case OpGreater64U: - return rewriteValuePPC64_OpGreater64U(v) + return rewriteValuePPC64_OpGreater64U_0(v) case OpGreater8: - return rewriteValuePPC64_OpGreater8(v) + return rewriteValuePPC64_OpGreater8_0(v) case OpGreater8U: - return rewriteValuePPC64_OpGreater8U(v) + return rewriteValuePPC64_OpGreater8U_0(v) case OpHmul32: - return rewriteValuePPC64_OpHmul32(v) + return rewriteValuePPC64_OpHmul32_0(v) case OpHmul32u: - return rewriteValuePPC64_OpHmul32u(v) + return rewriteValuePPC64_OpHmul32u_0(v) case OpHmul64: - return rewriteValuePPC64_OpHmul64(v) + return rewriteValuePPC64_OpHmul64_0(v) case OpHmul64u: - return rewriteValuePPC64_OpHmul64u(v) + return rewriteValuePPC64_OpHmul64u_0(v) case OpInterCall: - return rewriteValuePPC64_OpInterCall(v) + return rewriteValuePPC64_OpInterCall_0(v) case OpIsInBounds: - return rewriteValuePPC64_OpIsInBounds(v) + return rewriteValuePPC64_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValuePPC64_OpIsNonNil(v) + return rewriteValuePPC64_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValuePPC64_OpIsSliceInBounds(v) + return rewriteValuePPC64_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValuePPC64_OpLeq16(v) + return rewriteValuePPC64_OpLeq16_0(v) case OpLeq16U: - return rewriteValuePPC64_OpLeq16U(v) + return rewriteValuePPC64_OpLeq16U_0(v) case OpLeq32: - return rewriteValuePPC64_OpLeq32(v) + return rewriteValuePPC64_OpLeq32_0(v) case OpLeq32F: - return rewriteValuePPC64_OpLeq32F(v) + return rewriteValuePPC64_OpLeq32F_0(v) case OpLeq32U: - return rewriteValuePPC64_OpLeq32U(v) + return rewriteValuePPC64_OpLeq32U_0(v) case OpLeq64: - return rewriteValuePPC64_OpLeq64(v) + return rewriteValuePPC64_OpLeq64_0(v) case OpLeq64F: - return rewriteValuePPC64_OpLeq64F(v) + return rewriteValuePPC64_OpLeq64F_0(v) case OpLeq64U: - return rewriteValuePPC64_OpLeq64U(v) + return rewriteValuePPC64_OpLeq64U_0(v) case OpLeq8: - return rewriteValuePPC64_OpLeq8(v) + return rewriteValuePPC64_OpLeq8_0(v) case OpLeq8U: - return rewriteValuePPC64_OpLeq8U(v) + return rewriteValuePPC64_OpLeq8U_0(v) case OpLess16: - return rewriteValuePPC64_OpLess16(v) + return rewriteValuePPC64_OpLess16_0(v) case OpLess16U: - return rewriteValuePPC64_OpLess16U(v) + return rewriteValuePPC64_OpLess16U_0(v) case OpLess32: - return rewriteValuePPC64_OpLess32(v) + return rewriteValuePPC64_OpLess32_0(v) case OpLess32F: - return rewriteValuePPC64_OpLess32F(v) + return rewriteValuePPC64_OpLess32F_0(v) case OpLess32U: - return rewriteValuePPC64_OpLess32U(v) + return rewriteValuePPC64_OpLess32U_0(v) case OpLess64: - return rewriteValuePPC64_OpLess64(v) + return rewriteValuePPC64_OpLess64_0(v) case OpLess64F: - return rewriteValuePPC64_OpLess64F(v) + return rewriteValuePPC64_OpLess64F_0(v) case OpLess64U: - return rewriteValuePPC64_OpLess64U(v) + return rewriteValuePPC64_OpLess64U_0(v) case OpLess8: - return rewriteValuePPC64_OpLess8(v) + return rewriteValuePPC64_OpLess8_0(v) case OpLess8U: - return rewriteValuePPC64_OpLess8U(v) + return rewriteValuePPC64_OpLess8U_0(v) case OpLoad: - return rewriteValuePPC64_OpLoad(v) + return rewriteValuePPC64_OpLoad_0(v) case OpLsh16x16: - return rewriteValuePPC64_OpLsh16x16(v) + return rewriteValuePPC64_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValuePPC64_OpLsh16x32(v) + return rewriteValuePPC64_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValuePPC64_OpLsh16x64(v) + return rewriteValuePPC64_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValuePPC64_OpLsh16x8(v) + return rewriteValuePPC64_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValuePPC64_OpLsh32x16(v) + return rewriteValuePPC64_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValuePPC64_OpLsh32x32(v) + return rewriteValuePPC64_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValuePPC64_OpLsh32x64(v) + return rewriteValuePPC64_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValuePPC64_OpLsh32x8(v) + return rewriteValuePPC64_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValuePPC64_OpLsh64x16(v) + return rewriteValuePPC64_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValuePPC64_OpLsh64x32(v) + return rewriteValuePPC64_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValuePPC64_OpLsh64x64(v) + return rewriteValuePPC64_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValuePPC64_OpLsh64x8(v) + return rewriteValuePPC64_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValuePPC64_OpLsh8x16(v) + return rewriteValuePPC64_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValuePPC64_OpLsh8x32(v) + return rewriteValuePPC64_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValuePPC64_OpLsh8x64(v) + return rewriteValuePPC64_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValuePPC64_OpLsh8x8(v) + return rewriteValuePPC64_OpLsh8x8_0(v) case OpMod16: - return rewriteValuePPC64_OpMod16(v) + return rewriteValuePPC64_OpMod16_0(v) case OpMod16u: - return rewriteValuePPC64_OpMod16u(v) + return rewriteValuePPC64_OpMod16u_0(v) case OpMod32: - return rewriteValuePPC64_OpMod32(v) + return rewriteValuePPC64_OpMod32_0(v) case OpMod32u: - return rewriteValuePPC64_OpMod32u(v) + return rewriteValuePPC64_OpMod32u_0(v) case OpMod64: - return rewriteValuePPC64_OpMod64(v) + return rewriteValuePPC64_OpMod64_0(v) case OpMod64u: - return rewriteValuePPC64_OpMod64u(v) + return rewriteValuePPC64_OpMod64u_0(v) case OpMod8: - return rewriteValuePPC64_OpMod8(v) + return rewriteValuePPC64_OpMod8_0(v) case OpMod8u: - return rewriteValuePPC64_OpMod8u(v) + return rewriteValuePPC64_OpMod8u_0(v) case OpMove: - return rewriteValuePPC64_OpMove(v) + return rewriteValuePPC64_OpMove_0(v) || rewriteValuePPC64_OpMove_10(v) case OpMul16: - return rewriteValuePPC64_OpMul16(v) + return rewriteValuePPC64_OpMul16_0(v) case OpMul32: - return rewriteValuePPC64_OpMul32(v) + return rewriteValuePPC64_OpMul32_0(v) case OpMul32F: - return rewriteValuePPC64_OpMul32F(v) + return rewriteValuePPC64_OpMul32F_0(v) case OpMul64: - return rewriteValuePPC64_OpMul64(v) + return rewriteValuePPC64_OpMul64_0(v) case OpMul64F: - return rewriteValuePPC64_OpMul64F(v) + return rewriteValuePPC64_OpMul64F_0(v) case OpMul8: - return rewriteValuePPC64_OpMul8(v) + return rewriteValuePPC64_OpMul8_0(v) case OpNeg16: - return rewriteValuePPC64_OpNeg16(v) + return rewriteValuePPC64_OpNeg16_0(v) case OpNeg32: - return rewriteValuePPC64_OpNeg32(v) + return rewriteValuePPC64_OpNeg32_0(v) case OpNeg32F: - return rewriteValuePPC64_OpNeg32F(v) + return rewriteValuePPC64_OpNeg32F_0(v) case OpNeg64: - return rewriteValuePPC64_OpNeg64(v) + return rewriteValuePPC64_OpNeg64_0(v) case OpNeg64F: - return rewriteValuePPC64_OpNeg64F(v) + return rewriteValuePPC64_OpNeg64F_0(v) case OpNeg8: - return rewriteValuePPC64_OpNeg8(v) + return rewriteValuePPC64_OpNeg8_0(v) case OpNeq16: - return rewriteValuePPC64_OpNeq16(v) + return rewriteValuePPC64_OpNeq16_0(v) case OpNeq32: - return rewriteValuePPC64_OpNeq32(v) + return rewriteValuePPC64_OpNeq32_0(v) case OpNeq32F: - return rewriteValuePPC64_OpNeq32F(v) + return rewriteValuePPC64_OpNeq32F_0(v) case OpNeq64: - return rewriteValuePPC64_OpNeq64(v) + return rewriteValuePPC64_OpNeq64_0(v) case OpNeq64F: - return rewriteValuePPC64_OpNeq64F(v) + return rewriteValuePPC64_OpNeq64F_0(v) case OpNeq8: - return rewriteValuePPC64_OpNeq8(v) + return rewriteValuePPC64_OpNeq8_0(v) case OpNeqB: - return rewriteValuePPC64_OpNeqB(v) + return rewriteValuePPC64_OpNeqB_0(v) case OpNeqPtr: - return rewriteValuePPC64_OpNeqPtr(v) + return rewriteValuePPC64_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValuePPC64_OpNilCheck(v) + return rewriteValuePPC64_OpNilCheck_0(v) case OpNot: - return rewriteValuePPC64_OpNot(v) + return rewriteValuePPC64_OpNot_0(v) case OpOffPtr: - return rewriteValuePPC64_OpOffPtr(v) + return rewriteValuePPC64_OpOffPtr_0(v) case OpOr16: - return rewriteValuePPC64_OpOr16(v) + return rewriteValuePPC64_OpOr16_0(v) case OpOr32: - return rewriteValuePPC64_OpOr32(v) + return rewriteValuePPC64_OpOr32_0(v) case OpOr64: - return rewriteValuePPC64_OpOr64(v) + return rewriteValuePPC64_OpOr64_0(v) case OpOr8: - return rewriteValuePPC64_OpOr8(v) + return rewriteValuePPC64_OpOr8_0(v) case OpOrB: - return rewriteValuePPC64_OpOrB(v) + return rewriteValuePPC64_OpOrB_0(v) case OpPPC64ADD: - return rewriteValuePPC64_OpPPC64ADD(v) + return rewriteValuePPC64_OpPPC64ADD_0(v) case OpPPC64ADDconst: - return rewriteValuePPC64_OpPPC64ADDconst(v) + return rewriteValuePPC64_OpPPC64ADDconst_0(v) case OpPPC64AND: - return rewriteValuePPC64_OpPPC64AND(v) + return rewriteValuePPC64_OpPPC64AND_0(v) case OpPPC64ANDconst: - return rewriteValuePPC64_OpPPC64ANDconst(v) + return rewriteValuePPC64_OpPPC64ANDconst_0(v) case OpPPC64CMP: - return rewriteValuePPC64_OpPPC64CMP(v) + return rewriteValuePPC64_OpPPC64CMP_0(v) case OpPPC64CMPU: - return rewriteValuePPC64_OpPPC64CMPU(v) + return rewriteValuePPC64_OpPPC64CMPU_0(v) case OpPPC64CMPUconst: - return rewriteValuePPC64_OpPPC64CMPUconst(v) + return rewriteValuePPC64_OpPPC64CMPUconst_0(v) case OpPPC64CMPW: - return rewriteValuePPC64_OpPPC64CMPW(v) + return rewriteValuePPC64_OpPPC64CMPW_0(v) case OpPPC64CMPWU: - return rewriteValuePPC64_OpPPC64CMPWU(v) + return rewriteValuePPC64_OpPPC64CMPWU_0(v) case OpPPC64CMPWUconst: - return rewriteValuePPC64_OpPPC64CMPWUconst(v) + return rewriteValuePPC64_OpPPC64CMPWUconst_0(v) case OpPPC64CMPWconst: - return rewriteValuePPC64_OpPPC64CMPWconst(v) + return rewriteValuePPC64_OpPPC64CMPWconst_0(v) case OpPPC64CMPconst: - return rewriteValuePPC64_OpPPC64CMPconst(v) + return rewriteValuePPC64_OpPPC64CMPconst_0(v) case OpPPC64Equal: - return rewriteValuePPC64_OpPPC64Equal(v) + return rewriteValuePPC64_OpPPC64Equal_0(v) case OpPPC64FADD: - return rewriteValuePPC64_OpPPC64FADD(v) + return rewriteValuePPC64_OpPPC64FADD_0(v) case OpPPC64FADDS: - return rewriteValuePPC64_OpPPC64FADDS(v) + return rewriteValuePPC64_OpPPC64FADDS_0(v) case OpPPC64FMOVDload: - return rewriteValuePPC64_OpPPC64FMOVDload(v) + return rewriteValuePPC64_OpPPC64FMOVDload_0(v) case OpPPC64FMOVDstore: - return rewriteValuePPC64_OpPPC64FMOVDstore(v) + return rewriteValuePPC64_OpPPC64FMOVDstore_0(v) case OpPPC64FMOVSload: - return rewriteValuePPC64_OpPPC64FMOVSload(v) + return rewriteValuePPC64_OpPPC64FMOVSload_0(v) case OpPPC64FMOVSstore: - return rewriteValuePPC64_OpPPC64FMOVSstore(v) + return rewriteValuePPC64_OpPPC64FMOVSstore_0(v) case OpPPC64FSUB: - return rewriteValuePPC64_OpPPC64FSUB(v) + return rewriteValuePPC64_OpPPC64FSUB_0(v) case OpPPC64FSUBS: - return rewriteValuePPC64_OpPPC64FSUBS(v) + return rewriteValuePPC64_OpPPC64FSUBS_0(v) case OpPPC64GreaterEqual: - return rewriteValuePPC64_OpPPC64GreaterEqual(v) + return rewriteValuePPC64_OpPPC64GreaterEqual_0(v) case OpPPC64GreaterThan: - return rewriteValuePPC64_OpPPC64GreaterThan(v) + return rewriteValuePPC64_OpPPC64GreaterThan_0(v) case OpPPC64LessEqual: - return rewriteValuePPC64_OpPPC64LessEqual(v) + return rewriteValuePPC64_OpPPC64LessEqual_0(v) case OpPPC64LessThan: - return rewriteValuePPC64_OpPPC64LessThan(v) + return rewriteValuePPC64_OpPPC64LessThan_0(v) case OpPPC64MOVBZload: - return rewriteValuePPC64_OpPPC64MOVBZload(v) + return rewriteValuePPC64_OpPPC64MOVBZload_0(v) case OpPPC64MOVBZreg: - return rewriteValuePPC64_OpPPC64MOVBZreg(v) + return rewriteValuePPC64_OpPPC64MOVBZreg_0(v) case OpPPC64MOVBreg: - return rewriteValuePPC64_OpPPC64MOVBreg(v) + return rewriteValuePPC64_OpPPC64MOVBreg_0(v) case OpPPC64MOVBstore: - return rewriteValuePPC64_OpPPC64MOVBstore(v) + return rewriteValuePPC64_OpPPC64MOVBstore_0(v) case OpPPC64MOVBstorezero: - return rewriteValuePPC64_OpPPC64MOVBstorezero(v) + return rewriteValuePPC64_OpPPC64MOVBstorezero_0(v) case OpPPC64MOVDload: - return rewriteValuePPC64_OpPPC64MOVDload(v) + return rewriteValuePPC64_OpPPC64MOVDload_0(v) case OpPPC64MOVDstore: - return rewriteValuePPC64_OpPPC64MOVDstore(v) + return rewriteValuePPC64_OpPPC64MOVDstore_0(v) case OpPPC64MOVDstorezero: - return rewriteValuePPC64_OpPPC64MOVDstorezero(v) + return rewriteValuePPC64_OpPPC64MOVDstorezero_0(v) case OpPPC64MOVHZload: - return rewriteValuePPC64_OpPPC64MOVHZload(v) + return rewriteValuePPC64_OpPPC64MOVHZload_0(v) case OpPPC64MOVHZreg: - return rewriteValuePPC64_OpPPC64MOVHZreg(v) + return rewriteValuePPC64_OpPPC64MOVHZreg_0(v) case OpPPC64MOVHload: - return rewriteValuePPC64_OpPPC64MOVHload(v) + return rewriteValuePPC64_OpPPC64MOVHload_0(v) case OpPPC64MOVHreg: - return rewriteValuePPC64_OpPPC64MOVHreg(v) + return rewriteValuePPC64_OpPPC64MOVHreg_0(v) case OpPPC64MOVHstore: - return rewriteValuePPC64_OpPPC64MOVHstore(v) + return rewriteValuePPC64_OpPPC64MOVHstore_0(v) case OpPPC64MOVHstorezero: - return rewriteValuePPC64_OpPPC64MOVHstorezero(v) + return rewriteValuePPC64_OpPPC64MOVHstorezero_0(v) case OpPPC64MOVWZload: - return rewriteValuePPC64_OpPPC64MOVWZload(v) + return rewriteValuePPC64_OpPPC64MOVWZload_0(v) case OpPPC64MOVWZreg: - return rewriteValuePPC64_OpPPC64MOVWZreg(v) + return rewriteValuePPC64_OpPPC64MOVWZreg_0(v) case OpPPC64MOVWload: - return rewriteValuePPC64_OpPPC64MOVWload(v) + return rewriteValuePPC64_OpPPC64MOVWload_0(v) case OpPPC64MOVWreg: - return rewriteValuePPC64_OpPPC64MOVWreg(v) + return rewriteValuePPC64_OpPPC64MOVWreg_0(v) case OpPPC64MOVWstore: - return rewriteValuePPC64_OpPPC64MOVWstore(v) + return rewriteValuePPC64_OpPPC64MOVWstore_0(v) case OpPPC64MOVWstorezero: - return rewriteValuePPC64_OpPPC64MOVWstorezero(v) + return rewriteValuePPC64_OpPPC64MOVWstorezero_0(v) case OpPPC64MaskIfNotCarry: - return rewriteValuePPC64_OpPPC64MaskIfNotCarry(v) + return rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v) case OpPPC64NotEqual: - return rewriteValuePPC64_OpPPC64NotEqual(v) + return rewriteValuePPC64_OpPPC64NotEqual_0(v) case OpPPC64OR: - return rewriteValuePPC64_OpPPC64OR(v) + return rewriteValuePPC64_OpPPC64OR_0(v) case OpPPC64ORN: - return rewriteValuePPC64_OpPPC64ORN(v) + return rewriteValuePPC64_OpPPC64ORN_0(v) case OpPPC64ORconst: - return rewriteValuePPC64_OpPPC64ORconst(v) + return rewriteValuePPC64_OpPPC64ORconst_0(v) case OpPPC64SUB: - return rewriteValuePPC64_OpPPC64SUB(v) + return rewriteValuePPC64_OpPPC64SUB_0(v) case OpPPC64XOR: - return rewriteValuePPC64_OpPPC64XOR(v) + return rewriteValuePPC64_OpPPC64XOR_0(v) case OpPPC64XORconst: - return rewriteValuePPC64_OpPPC64XORconst(v) + return rewriteValuePPC64_OpPPC64XORconst_0(v) case OpRound32F: - return rewriteValuePPC64_OpRound32F(v) + return rewriteValuePPC64_OpRound32F_0(v) case OpRound64F: - return rewriteValuePPC64_OpRound64F(v) + return rewriteValuePPC64_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValuePPC64_OpRsh16Ux16(v) + return rewriteValuePPC64_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValuePPC64_OpRsh16Ux32(v) + return rewriteValuePPC64_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValuePPC64_OpRsh16Ux64(v) + return rewriteValuePPC64_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValuePPC64_OpRsh16Ux8(v) + return rewriteValuePPC64_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValuePPC64_OpRsh16x16(v) + return rewriteValuePPC64_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValuePPC64_OpRsh16x32(v) + return rewriteValuePPC64_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValuePPC64_OpRsh16x64(v) + return rewriteValuePPC64_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValuePPC64_OpRsh16x8(v) + return rewriteValuePPC64_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValuePPC64_OpRsh32Ux16(v) + return rewriteValuePPC64_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValuePPC64_OpRsh32Ux32(v) + return rewriteValuePPC64_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValuePPC64_OpRsh32Ux64(v) + return rewriteValuePPC64_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValuePPC64_OpRsh32Ux8(v) + return rewriteValuePPC64_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValuePPC64_OpRsh32x16(v) + return rewriteValuePPC64_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValuePPC64_OpRsh32x32(v) + return rewriteValuePPC64_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValuePPC64_OpRsh32x64(v) + return rewriteValuePPC64_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValuePPC64_OpRsh32x8(v) + return rewriteValuePPC64_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValuePPC64_OpRsh64Ux16(v) + return rewriteValuePPC64_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValuePPC64_OpRsh64Ux32(v) + return rewriteValuePPC64_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValuePPC64_OpRsh64Ux64(v) + return rewriteValuePPC64_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValuePPC64_OpRsh64Ux8(v) + return rewriteValuePPC64_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValuePPC64_OpRsh64x16(v) + return rewriteValuePPC64_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValuePPC64_OpRsh64x32(v) + return rewriteValuePPC64_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValuePPC64_OpRsh64x64(v) + return rewriteValuePPC64_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValuePPC64_OpRsh64x8(v) + return rewriteValuePPC64_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValuePPC64_OpRsh8Ux16(v) + return rewriteValuePPC64_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValuePPC64_OpRsh8Ux32(v) + return rewriteValuePPC64_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValuePPC64_OpRsh8Ux64(v) + return rewriteValuePPC64_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValuePPC64_OpRsh8Ux8(v) + return rewriteValuePPC64_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValuePPC64_OpRsh8x16(v) + return rewriteValuePPC64_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValuePPC64_OpRsh8x32(v) + return rewriteValuePPC64_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValuePPC64_OpRsh8x64(v) + return rewriteValuePPC64_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValuePPC64_OpRsh8x8(v) + return rewriteValuePPC64_OpRsh8x8_0(v) case OpSignExt16to32: - return rewriteValuePPC64_OpSignExt16to32(v) + return rewriteValuePPC64_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValuePPC64_OpSignExt16to64(v) + return rewriteValuePPC64_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValuePPC64_OpSignExt32to64(v) + return rewriteValuePPC64_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValuePPC64_OpSignExt8to16(v) + return rewriteValuePPC64_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValuePPC64_OpSignExt8to32(v) + return rewriteValuePPC64_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValuePPC64_OpSignExt8to64(v) + return rewriteValuePPC64_OpSignExt8to64_0(v) case OpSlicemask: - return rewriteValuePPC64_OpSlicemask(v) + return rewriteValuePPC64_OpSlicemask_0(v) case OpSqrt: - return rewriteValuePPC64_OpSqrt(v) + return rewriteValuePPC64_OpSqrt_0(v) case OpStaticCall: - return rewriteValuePPC64_OpStaticCall(v) + return rewriteValuePPC64_OpStaticCall_0(v) case OpStore: - return rewriteValuePPC64_OpStore(v) + return rewriteValuePPC64_OpStore_0(v) case OpSub16: - return rewriteValuePPC64_OpSub16(v) + return rewriteValuePPC64_OpSub16_0(v) case OpSub32: - return rewriteValuePPC64_OpSub32(v) + return rewriteValuePPC64_OpSub32_0(v) case OpSub32F: - return rewriteValuePPC64_OpSub32F(v) + return rewriteValuePPC64_OpSub32F_0(v) case OpSub64: - return rewriteValuePPC64_OpSub64(v) + return rewriteValuePPC64_OpSub64_0(v) case OpSub64F: - return rewriteValuePPC64_OpSub64F(v) + return rewriteValuePPC64_OpSub64F_0(v) case OpSub8: - return rewriteValuePPC64_OpSub8(v) + return rewriteValuePPC64_OpSub8_0(v) case OpSubPtr: - return rewriteValuePPC64_OpSubPtr(v) + return rewriteValuePPC64_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValuePPC64_OpTrunc16to8(v) + return rewriteValuePPC64_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValuePPC64_OpTrunc32to16(v) + return rewriteValuePPC64_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValuePPC64_OpTrunc32to8(v) + return rewriteValuePPC64_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValuePPC64_OpTrunc64to16(v) + return rewriteValuePPC64_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValuePPC64_OpTrunc64to32(v) + return rewriteValuePPC64_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValuePPC64_OpTrunc64to8(v) + return rewriteValuePPC64_OpTrunc64to8_0(v) case OpXor16: - return rewriteValuePPC64_OpXor16(v) + return rewriteValuePPC64_OpXor16_0(v) case OpXor32: - return rewriteValuePPC64_OpXor32(v) + return rewriteValuePPC64_OpXor32_0(v) case OpXor64: - return rewriteValuePPC64_OpXor64(v) + return rewriteValuePPC64_OpXor64_0(v) case OpXor8: - return rewriteValuePPC64_OpXor8(v) + return rewriteValuePPC64_OpXor8_0(v) case OpZero: - return rewriteValuePPC64_OpZero(v) + return rewriteValuePPC64_OpZero_0(v) || rewriteValuePPC64_OpZero_10(v) case OpZeroExt16to32: - return rewriteValuePPC64_OpZeroExt16to32(v) + return rewriteValuePPC64_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValuePPC64_OpZeroExt16to64(v) + return rewriteValuePPC64_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValuePPC64_OpZeroExt32to64(v) + return rewriteValuePPC64_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValuePPC64_OpZeroExt8to16(v) + return rewriteValuePPC64_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValuePPC64_OpZeroExt8to32(v) + return rewriteValuePPC64_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValuePPC64_OpZeroExt8to64(v) + return rewriteValuePPC64_OpZeroExt8to64_0(v) } return false } -func rewriteValuePPC64_OpAdd16(v *Value) bool { +func rewriteValuePPC64_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADD x y) @@ -615,7 +615,7 @@ func rewriteValuePPC64_OpAdd16(v *Value) bool { return true } } -func rewriteValuePPC64_OpAdd32(v *Value) bool { +func rewriteValuePPC64_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADD x y) @@ -628,7 +628,7 @@ func rewriteValuePPC64_OpAdd32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAdd32F(v *Value) bool { +func rewriteValuePPC64_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -641,7 +641,7 @@ func rewriteValuePPC64_OpAdd32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpAdd64(v *Value) bool { +func rewriteValuePPC64_OpAdd64_0(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -654,7 +654,7 @@ func rewriteValuePPC64_OpAdd64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAdd64F(v *Value) bool { +func rewriteValuePPC64_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADD x y) @@ -667,7 +667,7 @@ func rewriteValuePPC64_OpAdd64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpAdd8(v *Value) bool { +func rewriteValuePPC64_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADD x y) @@ -680,7 +680,7 @@ func rewriteValuePPC64_OpAdd8(v *Value) bool { return true } } -func rewriteValuePPC64_OpAddPtr(v *Value) bool { +func rewriteValuePPC64_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -693,7 +693,7 @@ func rewriteValuePPC64_OpAddPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpAddr(v *Value) bool { +func rewriteValuePPC64_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -706,7 +706,7 @@ func rewriteValuePPC64_OpAddr(v *Value) bool { return true } } -func rewriteValuePPC64_OpAnd16(v *Value) bool { +func rewriteValuePPC64_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (AND x y) @@ -719,7 +719,7 @@ func rewriteValuePPC64_OpAnd16(v *Value) bool { return true } } -func rewriteValuePPC64_OpAnd32(v *Value) bool { +func rewriteValuePPC64_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (AND x y) @@ -732,7 +732,7 @@ func rewriteValuePPC64_OpAnd32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAnd64(v *Value) bool { +func rewriteValuePPC64_OpAnd64_0(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -745,7 +745,7 @@ func rewriteValuePPC64_OpAnd64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAnd8(v *Value) bool { +func rewriteValuePPC64_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (AND x y) @@ -758,7 +758,7 @@ func rewriteValuePPC64_OpAnd8(v *Value) bool { return true } } -func rewriteValuePPC64_OpAndB(v *Value) bool { +func rewriteValuePPC64_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (AND x y) @@ -771,7 +771,7 @@ func rewriteValuePPC64_OpAndB(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool { +func rewriteValuePPC64_OpAtomicAdd32_0(v *Value) bool { // match: (AtomicAdd32 ptr val mem) // cond: // result: (LoweredAtomicAdd32 ptr val mem) @@ -786,7 +786,7 @@ func rewriteValuePPC64_OpAtomicAdd32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool { +func rewriteValuePPC64_OpAtomicAdd64_0(v *Value) bool { // match: (AtomicAdd64 ptr val mem) // cond: // result: (LoweredAtomicAdd64 ptr val mem) @@ -801,7 +801,7 @@ func rewriteValuePPC64_OpAtomicAdd64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool { +func rewriteValuePPC64_OpAtomicAnd8_0(v *Value) bool { // match: (AtomicAnd8 ptr val mem) // cond: // result: (LoweredAtomicAnd8 ptr val mem) @@ -816,7 +816,7 @@ func rewriteValuePPC64_OpAtomicAnd8(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool { +func rewriteValuePPC64_OpAtomicCompareAndSwap32_0(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -833,7 +833,7 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool { +func rewriteValuePPC64_OpAtomicCompareAndSwap64_0(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -850,7 +850,7 @@ func rewriteValuePPC64_OpAtomicCompareAndSwap64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool { +func rewriteValuePPC64_OpAtomicExchange32_0(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -865,7 +865,7 @@ func rewriteValuePPC64_OpAtomicExchange32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool { +func rewriteValuePPC64_OpAtomicExchange64_0(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -880,7 +880,7 @@ func rewriteValuePPC64_OpAtomicExchange64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool { +func rewriteValuePPC64_OpAtomicLoad32_0(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (LoweredAtomicLoad32 ptr mem) @@ -893,7 +893,7 @@ func rewriteValuePPC64_OpAtomicLoad32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool { +func rewriteValuePPC64_OpAtomicLoad64_0(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (LoweredAtomicLoad64 ptr mem) @@ -906,7 +906,7 @@ func rewriteValuePPC64_OpAtomicLoad64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool { +func rewriteValuePPC64_OpAtomicLoadPtr_0(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (LoweredAtomicLoadPtr ptr mem) @@ -919,7 +919,7 @@ func rewriteValuePPC64_OpAtomicLoadPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicOr8(v *Value) bool { +func rewriteValuePPC64_OpAtomicOr8_0(v *Value) bool { // match: (AtomicOr8 ptr val mem) // cond: // result: (LoweredAtomicOr8 ptr val mem) @@ -934,7 +934,7 @@ func rewriteValuePPC64_OpAtomicOr8(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicStore32(v *Value) bool { +func rewriteValuePPC64_OpAtomicStore32_0(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (LoweredAtomicStore32 ptr val mem) @@ -949,7 +949,7 @@ func rewriteValuePPC64_OpAtomicStore32(v *Value) bool { return true } } -func rewriteValuePPC64_OpAtomicStore64(v *Value) bool { +func rewriteValuePPC64_OpAtomicStore64_0(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (LoweredAtomicStore64 ptr val mem) @@ -964,7 +964,7 @@ func rewriteValuePPC64_OpAtomicStore64(v *Value) bool { return true } } -func rewriteValuePPC64_OpAvg64u(v *Value) bool { +func rewriteValuePPC64_OpAvg64u_0(v *Value) bool { b := v.Block _ = b // match: (Avg64u x y) @@ -986,7 +986,7 @@ func rewriteValuePPC64_OpAvg64u(v *Value) bool { return true } } -func rewriteValuePPC64_OpClosureCall(v *Value) bool { +func rewriteValuePPC64_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1003,7 +1003,7 @@ func rewriteValuePPC64_OpClosureCall(v *Value) bool { return true } } -func rewriteValuePPC64_OpCom16(v *Value) bool { +func rewriteValuePPC64_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (NOR x x) @@ -1015,7 +1015,7 @@ func rewriteValuePPC64_OpCom16(v *Value) bool { return true } } -func rewriteValuePPC64_OpCom32(v *Value) bool { +func rewriteValuePPC64_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (NOR x x) @@ -1027,7 +1027,7 @@ func rewriteValuePPC64_OpCom32(v *Value) bool { return true } } -func rewriteValuePPC64_OpCom64(v *Value) bool { +func rewriteValuePPC64_OpCom64_0(v *Value) bool { // match: (Com64 x) // cond: // result: (NOR x x) @@ -1039,7 +1039,7 @@ func rewriteValuePPC64_OpCom64(v *Value) bool { return true } } -func rewriteValuePPC64_OpCom8(v *Value) bool { +func rewriteValuePPC64_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (NOR x x) @@ -1051,7 +1051,7 @@ func rewriteValuePPC64_OpCom8(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst16(v *Value) bool { +func rewriteValuePPC64_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -1062,7 +1062,7 @@ func rewriteValuePPC64_OpConst16(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst32(v *Value) bool { +func rewriteValuePPC64_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -1073,7 +1073,7 @@ func rewriteValuePPC64_OpConst32(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst32F(v *Value) bool { +func rewriteValuePPC64_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -1084,7 +1084,7 @@ func rewriteValuePPC64_OpConst32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst64(v *Value) bool { +func rewriteValuePPC64_OpConst64_0(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -1095,7 +1095,7 @@ func rewriteValuePPC64_OpConst64(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst64F(v *Value) bool { +func rewriteValuePPC64_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -1106,7 +1106,7 @@ func rewriteValuePPC64_OpConst64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpConst8(v *Value) bool { +func rewriteValuePPC64_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -1117,7 +1117,7 @@ func rewriteValuePPC64_OpConst8(v *Value) bool { return true } } -func rewriteValuePPC64_OpConstBool(v *Value) bool { +func rewriteValuePPC64_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -1128,7 +1128,7 @@ func rewriteValuePPC64_OpConstBool(v *Value) bool { return true } } -func rewriteValuePPC64_OpConstNil(v *Value) bool { +func rewriteValuePPC64_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -1138,7 +1138,7 @@ func rewriteValuePPC64_OpConstNil(v *Value) bool { return true } } -func rewriteValuePPC64_OpConvert(v *Value) bool { +func rewriteValuePPC64_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVDconvert x mem) @@ -1153,7 +1153,7 @@ func rewriteValuePPC64_OpConvert(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool { +func rewriteValuePPC64_OpCvt32Fto32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1170,7 +1170,7 @@ func rewriteValuePPC64_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool { +func rewriteValuePPC64_OpCvt32Fto64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1187,7 +1187,7 @@ func rewriteValuePPC64_OpCvt32Fto64(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool { +func rewriteValuePPC64_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: x @@ -1199,7 +1199,7 @@ func rewriteValuePPC64_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt32to32F(v *Value) bool { +func rewriteValuePPC64_OpCvt32to32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1220,7 +1220,7 @@ func rewriteValuePPC64_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt32to64F(v *Value) bool { +func rewriteValuePPC64_OpCvt32to64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1239,7 +1239,7 @@ func rewriteValuePPC64_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool { +func rewriteValuePPC64_OpCvt64Fto32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1256,7 +1256,7 @@ func rewriteValuePPC64_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool { +func rewriteValuePPC64_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (FRSP x) @@ -1267,7 +1267,7 @@ func rewriteValuePPC64_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool { +func rewriteValuePPC64_OpCvt64Fto64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1284,7 +1284,7 @@ func rewriteValuePPC64_OpCvt64Fto64(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt64to32F(v *Value) bool { +func rewriteValuePPC64_OpCvt64to32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1303,7 +1303,7 @@ func rewriteValuePPC64_OpCvt64to32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpCvt64to64F(v *Value) bool { +func rewriteValuePPC64_OpCvt64to64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1320,7 +1320,7 @@ func rewriteValuePPC64_OpCvt64to64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv16(v *Value) bool { +func rewriteValuePPC64_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1341,7 +1341,7 @@ func rewriteValuePPC64_OpDiv16(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv16u(v *Value) bool { +func rewriteValuePPC64_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1362,7 +1362,7 @@ func rewriteValuePPC64_OpDiv16u(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv32(v *Value) bool { +func rewriteValuePPC64_OpDiv32_0(v *Value) bool { // match: (Div32 x y) // cond: // result: (DIVW x y) @@ -1375,7 +1375,7 @@ func rewriteValuePPC64_OpDiv32(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv32F(v *Value) bool { +func rewriteValuePPC64_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -1388,7 +1388,7 @@ func rewriteValuePPC64_OpDiv32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv32u(v *Value) bool { +func rewriteValuePPC64_OpDiv32u_0(v *Value) bool { // match: (Div32u x y) // cond: // result: (DIVWU x y) @@ -1401,7 +1401,7 @@ func rewriteValuePPC64_OpDiv32u(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv64(v *Value) bool { +func rewriteValuePPC64_OpDiv64_0(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIVD x y) @@ -1414,7 +1414,7 @@ func rewriteValuePPC64_OpDiv64(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv64F(v *Value) bool { +func rewriteValuePPC64_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIV x y) @@ -1427,7 +1427,7 @@ func rewriteValuePPC64_OpDiv64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv64u(v *Value) bool { +func rewriteValuePPC64_OpDiv64u_0(v *Value) bool { // match: (Div64u x y) // cond: // result: (DIVDU x y) @@ -1440,7 +1440,7 @@ func rewriteValuePPC64_OpDiv64u(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv8(v *Value) bool { +func rewriteValuePPC64_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1461,7 +1461,7 @@ func rewriteValuePPC64_OpDiv8(v *Value) bool { return true } } -func rewriteValuePPC64_OpDiv8u(v *Value) bool { +func rewriteValuePPC64_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1482,7 +1482,7 @@ func rewriteValuePPC64_OpDiv8u(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq16(v *Value) bool { +func rewriteValuePPC64_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1525,7 +1525,7 @@ func rewriteValuePPC64_OpEq16(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq32(v *Value) bool { +func rewriteValuePPC64_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x y) @@ -1542,7 +1542,7 @@ func rewriteValuePPC64_OpEq32(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq32F(v *Value) bool { +func rewriteValuePPC64_OpEq32F_0(v *Value) bool { b := v.Block _ = b // match: (Eq32F x y) @@ -1559,7 +1559,7 @@ func rewriteValuePPC64_OpEq32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq64(v *Value) bool { +func rewriteValuePPC64_OpEq64_0(v *Value) bool { b := v.Block _ = b // match: (Eq64 x y) @@ -1576,7 +1576,7 @@ func rewriteValuePPC64_OpEq64(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq64F(v *Value) bool { +func rewriteValuePPC64_OpEq64F_0(v *Value) bool { b := v.Block _ = b // match: (Eq64F x y) @@ -1593,7 +1593,7 @@ func rewriteValuePPC64_OpEq64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpEq8(v *Value) bool { +func rewriteValuePPC64_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1636,7 +1636,7 @@ func rewriteValuePPC64_OpEq8(v *Value) bool { return true } } -func rewriteValuePPC64_OpEqB(v *Value) bool { +func rewriteValuePPC64_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1656,7 +1656,7 @@ func rewriteValuePPC64_OpEqB(v *Value) bool { return true } } -func rewriteValuePPC64_OpEqPtr(v *Value) bool { +func rewriteValuePPC64_OpEqPtr_0(v *Value) bool { b := v.Block _ = b // match: (EqPtr x y) @@ -1673,7 +1673,7 @@ func rewriteValuePPC64_OpEqPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq16(v *Value) bool { +func rewriteValuePPC64_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1696,7 +1696,7 @@ func rewriteValuePPC64_OpGeq16(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq16U(v *Value) bool { +func rewriteValuePPC64_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1719,7 +1719,7 @@ func rewriteValuePPC64_OpGeq16U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq32(v *Value) bool { +func rewriteValuePPC64_OpGeq32_0(v *Value) bool { b := v.Block _ = b // match: (Geq32 x y) @@ -1736,7 +1736,7 @@ func rewriteValuePPC64_OpGeq32(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq32F(v *Value) bool { +func rewriteValuePPC64_OpGeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Geq32F x y) @@ -1753,7 +1753,7 @@ func rewriteValuePPC64_OpGeq32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq32U(v *Value) bool { +func rewriteValuePPC64_OpGeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Geq32U x y) @@ -1770,7 +1770,7 @@ func rewriteValuePPC64_OpGeq32U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq64(v *Value) bool { +func rewriteValuePPC64_OpGeq64_0(v *Value) bool { b := v.Block _ = b // match: (Geq64 x y) @@ -1787,7 +1787,7 @@ func rewriteValuePPC64_OpGeq64(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq64F(v *Value) bool { +func rewriteValuePPC64_OpGeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Geq64F x y) @@ -1804,7 +1804,7 @@ func rewriteValuePPC64_OpGeq64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq64U(v *Value) bool { +func rewriteValuePPC64_OpGeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Geq64U x y) @@ -1821,7 +1821,7 @@ func rewriteValuePPC64_OpGeq64U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq8(v *Value) bool { +func rewriteValuePPC64_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1844,7 +1844,7 @@ func rewriteValuePPC64_OpGeq8(v *Value) bool { return true } } -func rewriteValuePPC64_OpGeq8U(v *Value) bool { +func rewriteValuePPC64_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1867,7 +1867,7 @@ func rewriteValuePPC64_OpGeq8U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool { +func rewriteValuePPC64_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -1876,7 +1876,7 @@ func rewriteValuePPC64_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater16(v *Value) bool { +func rewriteValuePPC64_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1899,7 +1899,7 @@ func rewriteValuePPC64_OpGreater16(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater16U(v *Value) bool { +func rewriteValuePPC64_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1922,7 +1922,7 @@ func rewriteValuePPC64_OpGreater16U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater32(v *Value) bool { +func rewriteValuePPC64_OpGreater32_0(v *Value) bool { b := v.Block _ = b // match: (Greater32 x y) @@ -1939,7 +1939,7 @@ func rewriteValuePPC64_OpGreater32(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater32F(v *Value) bool { +func rewriteValuePPC64_OpGreater32F_0(v *Value) bool { b := v.Block _ = b // match: (Greater32F x y) @@ -1956,7 +1956,7 @@ func rewriteValuePPC64_OpGreater32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater32U(v *Value) bool { +func rewriteValuePPC64_OpGreater32U_0(v *Value) bool { b := v.Block _ = b // match: (Greater32U x y) @@ -1973,7 +1973,7 @@ func rewriteValuePPC64_OpGreater32U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater64(v *Value) bool { +func rewriteValuePPC64_OpGreater64_0(v *Value) bool { b := v.Block _ = b // match: (Greater64 x y) @@ -1990,7 +1990,7 @@ func rewriteValuePPC64_OpGreater64(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater64F(v *Value) bool { +func rewriteValuePPC64_OpGreater64F_0(v *Value) bool { b := v.Block _ = b // match: (Greater64F x y) @@ -2007,7 +2007,7 @@ func rewriteValuePPC64_OpGreater64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater64U(v *Value) bool { +func rewriteValuePPC64_OpGreater64U_0(v *Value) bool { b := v.Block _ = b // match: (Greater64U x y) @@ -2024,7 +2024,7 @@ func rewriteValuePPC64_OpGreater64U(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater8(v *Value) bool { +func rewriteValuePPC64_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2047,7 +2047,7 @@ func rewriteValuePPC64_OpGreater8(v *Value) bool { return true } } -func rewriteValuePPC64_OpGreater8U(v *Value) bool { +func rewriteValuePPC64_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2070,7 +2070,7 @@ func rewriteValuePPC64_OpGreater8U(v *Value) bool { return true } } -func rewriteValuePPC64_OpHmul32(v *Value) bool { +func rewriteValuePPC64_OpHmul32_0(v *Value) bool { // match: (Hmul32 x y) // cond: // result: (MULHW x y) @@ -2083,7 +2083,7 @@ func rewriteValuePPC64_OpHmul32(v *Value) bool { return true } } -func rewriteValuePPC64_OpHmul32u(v *Value) bool { +func rewriteValuePPC64_OpHmul32u_0(v *Value) bool { // match: (Hmul32u x y) // cond: // result: (MULHWU x y) @@ -2096,7 +2096,7 @@ func rewriteValuePPC64_OpHmul32u(v *Value) bool { return true } } -func rewriteValuePPC64_OpHmul64(v *Value) bool { +func rewriteValuePPC64_OpHmul64_0(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULHD x y) @@ -2109,7 +2109,7 @@ func rewriteValuePPC64_OpHmul64(v *Value) bool { return true } } -func rewriteValuePPC64_OpHmul64u(v *Value) bool { +func rewriteValuePPC64_OpHmul64u_0(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (MULHDU x y) @@ -2122,7 +2122,7 @@ func rewriteValuePPC64_OpHmul64u(v *Value) bool { return true } } -func rewriteValuePPC64_OpInterCall(v *Value) bool { +func rewriteValuePPC64_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -2137,7 +2137,7 @@ func rewriteValuePPC64_OpInterCall(v *Value) bool { return true } } -func rewriteValuePPC64_OpIsInBounds(v *Value) bool { +func rewriteValuePPC64_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsInBounds idx len) @@ -2154,7 +2154,7 @@ func rewriteValuePPC64_OpIsInBounds(v *Value) bool { return true } } -func rewriteValuePPC64_OpIsNonNil(v *Value) bool { +func rewriteValuePPC64_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b // match: (IsNonNil ptr) @@ -2170,7 +2170,7 @@ func rewriteValuePPC64_OpIsNonNil(v *Value) bool { return true } } -func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool { +func rewriteValuePPC64_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b // match: (IsSliceInBounds idx len) @@ -2187,7 +2187,7 @@ func rewriteValuePPC64_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq16(v *Value) bool { +func rewriteValuePPC64_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2210,7 +2210,7 @@ func rewriteValuePPC64_OpLeq16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq16U(v *Value) bool { +func rewriteValuePPC64_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2233,7 +2233,7 @@ func rewriteValuePPC64_OpLeq16U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq32(v *Value) bool { +func rewriteValuePPC64_OpLeq32_0(v *Value) bool { b := v.Block _ = b // match: (Leq32 x y) @@ -2250,7 +2250,7 @@ func rewriteValuePPC64_OpLeq32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq32F(v *Value) bool { +func rewriteValuePPC64_OpLeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Leq32F x y) @@ -2267,7 +2267,7 @@ func rewriteValuePPC64_OpLeq32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq32U(v *Value) bool { +func rewriteValuePPC64_OpLeq32U_0(v *Value) bool { b := v.Block _ = b // match: (Leq32U x y) @@ -2284,7 +2284,7 @@ func rewriteValuePPC64_OpLeq32U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq64(v *Value) bool { +func rewriteValuePPC64_OpLeq64_0(v *Value) bool { b := v.Block _ = b // match: (Leq64 x y) @@ -2301,7 +2301,7 @@ func rewriteValuePPC64_OpLeq64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq64F(v *Value) bool { +func rewriteValuePPC64_OpLeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Leq64F x y) @@ -2318,7 +2318,7 @@ func rewriteValuePPC64_OpLeq64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq64U(v *Value) bool { +func rewriteValuePPC64_OpLeq64U_0(v *Value) bool { b := v.Block _ = b // match: (Leq64U x y) @@ -2335,7 +2335,7 @@ func rewriteValuePPC64_OpLeq64U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq8(v *Value) bool { +func rewriteValuePPC64_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2358,7 +2358,7 @@ func rewriteValuePPC64_OpLeq8(v *Value) bool { return true } } -func rewriteValuePPC64_OpLeq8U(v *Value) bool { +func rewriteValuePPC64_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2381,7 +2381,7 @@ func rewriteValuePPC64_OpLeq8U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess16(v *Value) bool { +func rewriteValuePPC64_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2404,7 +2404,7 @@ func rewriteValuePPC64_OpLess16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess16U(v *Value) bool { +func rewriteValuePPC64_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2427,7 +2427,7 @@ func rewriteValuePPC64_OpLess16U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess32(v *Value) bool { +func rewriteValuePPC64_OpLess32_0(v *Value) bool { b := v.Block _ = b // match: (Less32 x y) @@ -2444,7 +2444,7 @@ func rewriteValuePPC64_OpLess32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess32F(v *Value) bool { +func rewriteValuePPC64_OpLess32F_0(v *Value) bool { b := v.Block _ = b // match: (Less32F x y) @@ -2461,7 +2461,7 @@ func rewriteValuePPC64_OpLess32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess32U(v *Value) bool { +func rewriteValuePPC64_OpLess32U_0(v *Value) bool { b := v.Block _ = b // match: (Less32U x y) @@ -2478,7 +2478,7 @@ func rewriteValuePPC64_OpLess32U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess64(v *Value) bool { +func rewriteValuePPC64_OpLess64_0(v *Value) bool { b := v.Block _ = b // match: (Less64 x y) @@ -2495,7 +2495,7 @@ func rewriteValuePPC64_OpLess64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess64F(v *Value) bool { +func rewriteValuePPC64_OpLess64F_0(v *Value) bool { b := v.Block _ = b // match: (Less64F x y) @@ -2512,7 +2512,7 @@ func rewriteValuePPC64_OpLess64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess64U(v *Value) bool { +func rewriteValuePPC64_OpLess64U_0(v *Value) bool { b := v.Block _ = b // match: (Less64U x y) @@ -2529,7 +2529,7 @@ func rewriteValuePPC64_OpLess64U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess8(v *Value) bool { +func rewriteValuePPC64_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2552,7 +2552,7 @@ func rewriteValuePPC64_OpLess8(v *Value) bool { return true } } -func rewriteValuePPC64_OpLess8U(v *Value) bool { +func rewriteValuePPC64_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2575,7 +2575,7 @@ func rewriteValuePPC64_OpLess8U(v *Value) bool { return true } } -func rewriteValuePPC64_OpLoad(v *Value) bool { +func rewriteValuePPC64_OpLoad_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2734,7 +2734,7 @@ func rewriteValuePPC64_OpLoad(v *Value) bool { } return false } -func rewriteValuePPC64_OpLsh16x16(v *Value) bool { +func rewriteValuePPC64_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2761,7 +2761,7 @@ func rewriteValuePPC64_OpLsh16x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh16x32(v *Value) bool { +func rewriteValuePPC64_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2824,7 +2824,7 @@ func rewriteValuePPC64_OpLsh16x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh16x64(v *Value) bool { +func rewriteValuePPC64_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2901,7 +2901,7 @@ func rewriteValuePPC64_OpLsh16x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh16x8(v *Value) bool { +func rewriteValuePPC64_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2928,7 +2928,7 @@ func rewriteValuePPC64_OpLsh16x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh32x16(v *Value) bool { +func rewriteValuePPC64_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2955,7 +2955,7 @@ func rewriteValuePPC64_OpLsh32x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh32x32(v *Value) bool { +func rewriteValuePPC64_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3018,7 +3018,7 @@ func rewriteValuePPC64_OpLsh32x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh32x64(v *Value) bool { +func rewriteValuePPC64_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3095,7 +3095,7 @@ func rewriteValuePPC64_OpLsh32x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh32x8(v *Value) bool { +func rewriteValuePPC64_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3122,7 +3122,7 @@ func rewriteValuePPC64_OpLsh32x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh64x16(v *Value) bool { +func rewriteValuePPC64_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3149,7 +3149,7 @@ func rewriteValuePPC64_OpLsh64x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh64x32(v *Value) bool { +func rewriteValuePPC64_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3212,7 +3212,7 @@ func rewriteValuePPC64_OpLsh64x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh64x64(v *Value) bool { +func rewriteValuePPC64_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3289,7 +3289,7 @@ func rewriteValuePPC64_OpLsh64x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh64x8(v *Value) bool { +func rewriteValuePPC64_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3316,7 +3316,7 @@ func rewriteValuePPC64_OpLsh64x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh8x16(v *Value) bool { +func rewriteValuePPC64_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3343,7 +3343,7 @@ func rewriteValuePPC64_OpLsh8x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh8x32(v *Value) bool { +func rewriteValuePPC64_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3406,7 +3406,7 @@ func rewriteValuePPC64_OpLsh8x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh8x64(v *Value) bool { +func rewriteValuePPC64_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3483,7 +3483,7 @@ func rewriteValuePPC64_OpLsh8x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpLsh8x8(v *Value) bool { +func rewriteValuePPC64_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3510,7 +3510,7 @@ func rewriteValuePPC64_OpLsh8x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod16(v *Value) bool { +func rewriteValuePPC64_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3531,7 +3531,7 @@ func rewriteValuePPC64_OpMod16(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod16u(v *Value) bool { +func rewriteValuePPC64_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3552,7 +3552,7 @@ func rewriteValuePPC64_OpMod16u(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod32(v *Value) bool { +func rewriteValuePPC64_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3575,7 +3575,7 @@ func rewriteValuePPC64_OpMod32(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod32u(v *Value) bool { +func rewriteValuePPC64_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3598,7 +3598,7 @@ func rewriteValuePPC64_OpMod32u(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod64(v *Value) bool { +func rewriteValuePPC64_OpMod64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3621,7 +3621,7 @@ func rewriteValuePPC64_OpMod64(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod64u(v *Value) bool { +func rewriteValuePPC64_OpMod64u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3644,7 +3644,7 @@ func rewriteValuePPC64_OpMod64u(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod8(v *Value) bool { +func rewriteValuePPC64_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3665,7 +3665,7 @@ func rewriteValuePPC64_OpMod8(v *Value) bool { return true } } -func rewriteValuePPC64_OpMod8u(v *Value) bool { +func rewriteValuePPC64_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3686,7 +3686,7 @@ func rewriteValuePPC64_OpMod8u(v *Value) bool { return true } } -func rewriteValuePPC64_OpMove(v *Value) bool { +func rewriteValuePPC64_OpMove_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3933,6 +3933,9 @@ func rewriteValuePPC64_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValuePPC64_OpMove_10(v *Value) bool { // match: (Move [s] dst src mem) // cond: s > 8 // result: (LoweredMove [s] dst src mem) @@ -3953,7 +3956,7 @@ func rewriteValuePPC64_OpMove(v *Value) bool { } return false } -func rewriteValuePPC64_OpMul16(v *Value) bool { +func rewriteValuePPC64_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULLW x y) @@ -3966,7 +3969,7 @@ func rewriteValuePPC64_OpMul16(v *Value) bool { return true } } -func rewriteValuePPC64_OpMul32(v *Value) bool { +func rewriteValuePPC64_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULLW x y) @@ -3979,7 +3982,7 @@ func rewriteValuePPC64_OpMul32(v *Value) bool { return true } } -func rewriteValuePPC64_OpMul32F(v *Value) bool { +func rewriteValuePPC64_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -3992,7 +3995,7 @@ func rewriteValuePPC64_OpMul32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpMul64(v *Value) bool { +func rewriteValuePPC64_OpMul64_0(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULLD x y) @@ -4005,7 +4008,7 @@ func rewriteValuePPC64_OpMul64(v *Value) bool { return true } } -func rewriteValuePPC64_OpMul64F(v *Value) bool { +func rewriteValuePPC64_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMUL x y) @@ -4018,7 +4021,7 @@ func rewriteValuePPC64_OpMul64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpMul8(v *Value) bool { +func rewriteValuePPC64_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULLW x y) @@ -4031,7 +4034,7 @@ func rewriteValuePPC64_OpMul8(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg16(v *Value) bool { +func rewriteValuePPC64_OpNeg16_0(v *Value) bool { // match: (Neg16 x) // cond: // result: (NEG x) @@ -4042,7 +4045,7 @@ func rewriteValuePPC64_OpNeg16(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg32(v *Value) bool { +func rewriteValuePPC64_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEG x) @@ -4053,7 +4056,7 @@ func rewriteValuePPC64_OpNeg32(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg32F(v *Value) bool { +func rewriteValuePPC64_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEG x) @@ -4064,7 +4067,7 @@ func rewriteValuePPC64_OpNeg32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg64(v *Value) bool { +func rewriteValuePPC64_OpNeg64_0(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -4075,7 +4078,7 @@ func rewriteValuePPC64_OpNeg64(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg64F(v *Value) bool { +func rewriteValuePPC64_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEG x) @@ -4086,7 +4089,7 @@ func rewriteValuePPC64_OpNeg64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeg8(v *Value) bool { +func rewriteValuePPC64_OpNeg8_0(v *Value) bool { // match: (Neg8 x) // cond: // result: (NEG x) @@ -4097,7 +4100,7 @@ func rewriteValuePPC64_OpNeg8(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq16(v *Value) bool { +func rewriteValuePPC64_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4140,7 +4143,7 @@ func rewriteValuePPC64_OpNeq16(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq32(v *Value) bool { +func rewriteValuePPC64_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x y) @@ -4157,7 +4160,7 @@ func rewriteValuePPC64_OpNeq32(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq32F(v *Value) bool { +func rewriteValuePPC64_OpNeq32F_0(v *Value) bool { b := v.Block _ = b // match: (Neq32F x y) @@ -4174,7 +4177,7 @@ func rewriteValuePPC64_OpNeq32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq64(v *Value) bool { +func rewriteValuePPC64_OpNeq64_0(v *Value) bool { b := v.Block _ = b // match: (Neq64 x y) @@ -4191,7 +4194,7 @@ func rewriteValuePPC64_OpNeq64(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq64F(v *Value) bool { +func rewriteValuePPC64_OpNeq64F_0(v *Value) bool { b := v.Block _ = b // match: (Neq64F x y) @@ -4208,7 +4211,7 @@ func rewriteValuePPC64_OpNeq64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeq8(v *Value) bool { +func rewriteValuePPC64_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4251,7 +4254,7 @@ func rewriteValuePPC64_OpNeq8(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeqB(v *Value) bool { +func rewriteValuePPC64_OpNeqB_0(v *Value) bool { // match: (NeqB x y) // cond: // result: (XOR x y) @@ -4264,7 +4267,7 @@ func rewriteValuePPC64_OpNeqB(v *Value) bool { return true } } -func rewriteValuePPC64_OpNeqPtr(v *Value) bool { +func rewriteValuePPC64_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b // match: (NeqPtr x y) @@ -4281,7 +4284,7 @@ func rewriteValuePPC64_OpNeqPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpNilCheck(v *Value) bool { +func rewriteValuePPC64_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -4294,7 +4297,7 @@ func rewriteValuePPC64_OpNilCheck(v *Value) bool { return true } } -func rewriteValuePPC64_OpNot(v *Value) bool { +func rewriteValuePPC64_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORconst [1] x) @@ -4306,7 +4309,7 @@ func rewriteValuePPC64_OpNot(v *Value) bool { return true } } -func rewriteValuePPC64_OpOffPtr(v *Value) bool { +func rewriteValuePPC64_OpOffPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4325,7 +4328,7 @@ func rewriteValuePPC64_OpOffPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpOr16(v *Value) bool { +func rewriteValuePPC64_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (OR x y) @@ -4338,7 +4341,7 @@ func rewriteValuePPC64_OpOr16(v *Value) bool { return true } } -func rewriteValuePPC64_OpOr32(v *Value) bool { +func rewriteValuePPC64_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (OR x y) @@ -4351,7 +4354,7 @@ func rewriteValuePPC64_OpOr32(v *Value) bool { return true } } -func rewriteValuePPC64_OpOr64(v *Value) bool { +func rewriteValuePPC64_OpOr64_0(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -4364,7 +4367,7 @@ func rewriteValuePPC64_OpOr64(v *Value) bool { return true } } -func rewriteValuePPC64_OpOr8(v *Value) bool { +func rewriteValuePPC64_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (OR x y) @@ -4377,7 +4380,7 @@ func rewriteValuePPC64_OpOr8(v *Value) bool { return true } } -func rewriteValuePPC64_OpOrB(v *Value) bool { +func rewriteValuePPC64_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (OR x y) @@ -4390,7 +4393,7 @@ func rewriteValuePPC64_OpOrB(v *Value) bool { return true } } -func rewriteValuePPC64_OpPPC64ADD(v *Value) bool { +func rewriteValuePPC64_OpPPC64ADD_0(v *Value) bool { // match: (ADD (SLDconst x [c]) (SRDconst x [d])) // cond: d == 64-c // result: (ROTLconst [c] x) @@ -4533,7 +4536,7 @@ func rewriteValuePPC64_OpPPC64ADD(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64ADDconst_0(v *Value) bool { // match: (ADDconst [c] (ADDconst [d] x)) // cond: is32Bit(c+d) // result: (ADDconst [c+d] x) @@ -4586,7 +4589,7 @@ func rewriteValuePPC64_OpPPC64ADDconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64AND(v *Value) bool { +func rewriteValuePPC64_OpPPC64AND_0(v *Value) bool { // match: (AND x (NOR y y)) // cond: // result: (ANDN x y) @@ -4769,7 +4772,7 @@ func rewriteValuePPC64_OpPPC64AND(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64ANDconst_0(v *Value) bool { // match: (ANDconst [c] (ANDconst [d] x)) // cond: // result: (ANDconst [c&d] x) @@ -4908,7 +4911,7 @@ func rewriteValuePPC64_OpPPC64ANDconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMP(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMP_0(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -4951,7 +4954,7 @@ func rewriteValuePPC64_OpPPC64CMP(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPU_0(v *Value) bool { b := v.Block _ = b // match: (CMPU x (MOVDconst [c])) @@ -4994,7 +4997,7 @@ func rewriteValuePPC64_OpPPC64CMPU(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPUconst_0(v *Value) bool { // match: (CMPUconst (MOVDconst [x]) [y]) // cond: int64(x)==int64(y) // result: (FlagEQ) @@ -5045,7 +5048,7 @@ func rewriteValuePPC64_OpPPC64CMPUconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPW_0(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVWreg y)) @@ -5118,7 +5121,7 @@ func rewriteValuePPC64_OpPPC64CMPW(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPWU_0(v *Value) bool { b := v.Block _ = b // match: (CMPWU x (MOVWZreg y)) @@ -5191,7 +5194,7 @@ func rewriteValuePPC64_OpPPC64CMPWU(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPWUconst_0(v *Value) bool { // match: (CMPWUconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -5242,7 +5245,7 @@ func rewriteValuePPC64_OpPPC64CMPWUconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPWconst_0(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -5293,7 +5296,7 @@ func rewriteValuePPC64_OpPPC64CMPWconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64CMPconst_0(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: int64(x)==int64(y) // result: (FlagEQ) @@ -5344,7 +5347,7 @@ func rewriteValuePPC64_OpPPC64CMPconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64Equal(v *Value) bool { +func rewriteValuePPC64_OpPPC64Equal_0(v *Value) bool { // match: (Equal (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5396,7 +5399,7 @@ func rewriteValuePPC64_OpPPC64Equal(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FADD(v *Value) bool { +func rewriteValuePPC64_OpPPC64FADD_0(v *Value) bool { // match: (FADD (FMUL x y) z) // cond: // result: (FMADD x y z) @@ -5433,7 +5436,7 @@ func rewriteValuePPC64_OpPPC64FADD(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool { +func rewriteValuePPC64_OpPPC64FADDS_0(v *Value) bool { // match: (FADDS (FMULS x y) z) // cond: // result: (FMADDS x y z) @@ -5470,7 +5473,7 @@ func rewriteValuePPC64_OpPPC64FADDS(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool { +func rewriteValuePPC64_OpPPC64FMOVDload_0(v *Value) bool { // match: (FMOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (FMOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5520,7 +5523,7 @@ func rewriteValuePPC64_OpPPC64FMOVDload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64FMOVDstore_0(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is16Bit(off1+off2) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -5574,7 +5577,7 @@ func rewriteValuePPC64_OpPPC64FMOVDstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool { +func rewriteValuePPC64_OpPPC64FMOVSload_0(v *Value) bool { // match: (FMOVSload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (FMOVSload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5624,7 +5627,7 @@ func rewriteValuePPC64_OpPPC64FMOVSload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64FMOVSstore_0(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is16Bit(off1+off2) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -5678,7 +5681,7 @@ func rewriteValuePPC64_OpPPC64FMOVSstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool { +func rewriteValuePPC64_OpPPC64FSUB_0(v *Value) bool { // match: (FSUB (FMUL x y) z) // cond: // result: (FMSUB x y z) @@ -5698,7 +5701,7 @@ func rewriteValuePPC64_OpPPC64FSUB(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool { +func rewriteValuePPC64_OpPPC64FSUBS_0(v *Value) bool { // match: (FSUBS (FMULS x y) z) // cond: // result: (FMSUBS x y z) @@ -5718,7 +5721,7 @@ func rewriteValuePPC64_OpPPC64FSUBS(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool { +func rewriteValuePPC64_OpPPC64GreaterEqual_0(v *Value) bool { // match: (GreaterEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5770,7 +5773,7 @@ func rewriteValuePPC64_OpPPC64GreaterEqual(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool { +func rewriteValuePPC64_OpPPC64GreaterThan_0(v *Value) bool { // match: (GreaterThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -5822,7 +5825,7 @@ func rewriteValuePPC64_OpPPC64GreaterThan(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool { +func rewriteValuePPC64_OpPPC64LessEqual_0(v *Value) bool { // match: (LessEqual (FlagEQ)) // cond: // result: (MOVDconst [1]) @@ -5874,7 +5877,7 @@ func rewriteValuePPC64_OpPPC64LessEqual(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool { +func rewriteValuePPC64_OpPPC64LessThan_0(v *Value) bool { // match: (LessThan (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -5926,7 +5929,7 @@ func rewriteValuePPC64_OpPPC64LessThan(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVBZload_0(v *Value) bool { // match: (MOVBZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVBZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -5976,7 +5979,7 @@ func rewriteValuePPC64_OpPPC64MOVBZload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVBZreg_0(v *Value) bool { // match: (MOVBZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFF // result: y @@ -6048,7 +6051,7 @@ func rewriteValuePPC64_OpPPC64MOVBZreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVBreg_0(v *Value) bool { // match: (MOVBreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0x7F // result: y @@ -6107,7 +6110,7 @@ func rewriteValuePPC64_OpPPC64MOVBreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVBstore_0(v *Value) bool { // match: (MOVBstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVBstore [off1+off2] {sym} x val mem) @@ -6226,7 +6229,7 @@ func rewriteValuePPC64_OpPPC64MOVBstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVBstorezero_0(v *Value) bool { // match: (MOVBstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVBstorezero [off1+off2] {sym} x mem) @@ -6276,7 +6279,7 @@ func rewriteValuePPC64_OpPPC64MOVBstorezero(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVDload_0(v *Value) bool { // match: (MOVDload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVDload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6326,7 +6329,7 @@ func rewriteValuePPC64_OpPPC64MOVDload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} x val mem) @@ -6403,7 +6406,7 @@ func rewriteValuePPC64_OpPPC64MOVDstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVDstorezero_0(v *Value) bool { // match: (MOVDstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVDstorezero [off1+off2] {sym} x mem) @@ -6453,7 +6456,7 @@ func rewriteValuePPC64_OpPPC64MOVDstorezero(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHZload_0(v *Value) bool { // match: (MOVHZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVHZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6503,7 +6506,7 @@ func rewriteValuePPC64_OpPPC64MOVHZload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHZreg_0(v *Value) bool { // match: (MOVHZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFF // result: y @@ -6588,7 +6591,7 @@ func rewriteValuePPC64_OpPPC64MOVHZreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVHload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6638,7 +6641,7 @@ func rewriteValuePPC64_OpPPC64MOVHload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHreg_0(v *Value) bool { // match: (MOVHreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0x7FFF // result: y @@ -6723,7 +6726,7 @@ func rewriteValuePPC64_OpPPC64MOVHreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHstore_0(v *Value) bool { // match: (MOVHstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVHstore [off1+off2] {sym} x val mem) @@ -6842,7 +6845,7 @@ func rewriteValuePPC64_OpPPC64MOVHstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVHstorezero_0(v *Value) bool { // match: (MOVHstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVHstorezero [off1+off2] {sym} x mem) @@ -6892,7 +6895,7 @@ func rewriteValuePPC64_OpPPC64MOVHstorezero(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWZload_0(v *Value) bool { // match: (MOVWZload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVWZload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -6942,7 +6945,7 @@ func rewriteValuePPC64_OpPPC64MOVWZload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWZreg_0(v *Value) bool { // match: (MOVWZreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFFFFFF // result: y @@ -7056,7 +7059,7 @@ func rewriteValuePPC64_OpPPC64MOVWZreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWload_0(v *Value) bool { // match: (MOVWload [off1] {sym1} (MOVDaddr [off2] {sym2} ptr) mem) // cond: canMergeSym(sym1,sym2) // result: (MOVWload [off1+off2] {mergeSym(sym1,sym2)} ptr mem) @@ -7106,7 +7109,7 @@ func rewriteValuePPC64_OpPPC64MOVWload(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWreg_0(v *Value) bool { // match: (MOVWreg y:(ANDconst [c] _)) // cond: uint64(c) <= 0xFFFF // result: y @@ -7220,7 +7223,7 @@ func rewriteValuePPC64_OpPPC64MOVWreg(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWstore_0(v *Value) bool { // match: (MOVWstore [off1] {sym} (ADDconst [off2] x) val mem) // cond: is16Bit(off1+off2) // result: (MOVWstore [off1+off2] {sym} x val mem) @@ -7339,7 +7342,7 @@ func rewriteValuePPC64_OpPPC64MOVWstore(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool { +func rewriteValuePPC64_OpPPC64MOVWstorezero_0(v *Value) bool { // match: (MOVWstorezero [off1] {sym} (ADDconst [off2] x) mem) // cond: is16Bit(off1+off2) // result: (MOVWstorezero [off1+off2] {sym} x mem) @@ -7389,7 +7392,7 @@ func rewriteValuePPC64_OpPPC64MOVWstorezero(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool { +func rewriteValuePPC64_OpPPC64MaskIfNotCarry_0(v *Value) bool { // match: (MaskIfNotCarry (ADDconstForCarry [c] (ANDconst [d] _))) // cond: c < 0 && d > 0 && c + d < 0 // result: (MOVDconst [-1]) @@ -7413,7 +7416,7 @@ func rewriteValuePPC64_OpPPC64MaskIfNotCarry(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool { +func rewriteValuePPC64_OpPPC64NotEqual_0(v *Value) bool { // match: (NotEqual (FlagEQ)) // cond: // result: (MOVDconst [0]) @@ -7465,7 +7468,7 @@ func rewriteValuePPC64_OpPPC64NotEqual(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64OR(v *Value) bool { +func rewriteValuePPC64_OpPPC64OR_0(v *Value) bool { // match: (OR (SLDconst x [c]) (SRDconst x [d])) // cond: d == 64-c // result: (ROTLconst [c] x) @@ -7644,7 +7647,7 @@ func rewriteValuePPC64_OpPPC64OR(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64ORN(v *Value) bool { +func rewriteValuePPC64_OpPPC64ORN_0(v *Value) bool { // match: (ORN x (MOVDconst [-1])) // cond: // result: x @@ -7664,7 +7667,7 @@ func rewriteValuePPC64_OpPPC64ORN(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64ORconst_0(v *Value) bool { // match: (ORconst [c] (ORconst [d] x)) // cond: // result: (ORconst [c|d] x) @@ -7707,7 +7710,7 @@ func rewriteValuePPC64_OpPPC64ORconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64SUB(v *Value) bool { +func rewriteValuePPC64_OpPPC64SUB_0(v *Value) bool { // match: (SUB x (MOVDconst [c])) // cond: is32Bit(-c) // result: (ADDconst [-c] x) @@ -7728,7 +7731,7 @@ func rewriteValuePPC64_OpPPC64SUB(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64XOR(v *Value) bool { +func rewriteValuePPC64_OpPPC64XOR_0(v *Value) bool { // match: (XOR (SLDconst x [c]) (SRDconst x [d])) // cond: d == 64-c // result: (ROTLconst [c] x) @@ -7907,7 +7910,7 @@ func rewriteValuePPC64_OpPPC64XOR(v *Value) bool { } return false } -func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool { +func rewriteValuePPC64_OpPPC64XORconst_0(v *Value) bool { // match: (XORconst [c] (XORconst [d] x)) // cond: // result: (XORconst [c^d] x) @@ -7939,7 +7942,7 @@ func rewriteValuePPC64_OpPPC64XORconst(v *Value) bool { } return false } -func rewriteValuePPC64_OpRound32F(v *Value) bool { +func rewriteValuePPC64_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: (LoweredRound32F x) @@ -7950,7 +7953,7 @@ func rewriteValuePPC64_OpRound32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpRound64F(v *Value) bool { +func rewriteValuePPC64_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: (LoweredRound64F x) @@ -7961,7 +7964,7 @@ func rewriteValuePPC64_OpRound64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool { +func rewriteValuePPC64_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7990,7 +7993,7 @@ func rewriteValuePPC64_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool { +func rewriteValuePPC64_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8059,7 +8062,7 @@ func rewriteValuePPC64_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool { +func rewriteValuePPC64_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8142,7 +8145,7 @@ func rewriteValuePPC64_OpRsh16Ux64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool { +func rewriteValuePPC64_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8171,7 +8174,7 @@ func rewriteValuePPC64_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16x16(v *Value) bool { +func rewriteValuePPC64_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8200,7 +8203,7 @@ func rewriteValuePPC64_OpRsh16x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16x32(v *Value) bool { +func rewriteValuePPC64_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8269,7 +8272,7 @@ func rewriteValuePPC64_OpRsh16x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16x64(v *Value) bool { +func rewriteValuePPC64_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8356,7 +8359,7 @@ func rewriteValuePPC64_OpRsh16x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh16x8(v *Value) bool { +func rewriteValuePPC64_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8385,7 +8388,7 @@ func rewriteValuePPC64_OpRsh16x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool { +func rewriteValuePPC64_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8412,7 +8415,7 @@ func rewriteValuePPC64_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool { +func rewriteValuePPC64_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8475,7 +8478,7 @@ func rewriteValuePPC64_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool { +func rewriteValuePPC64_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8552,7 +8555,7 @@ func rewriteValuePPC64_OpRsh32Ux64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool { +func rewriteValuePPC64_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8579,7 +8582,7 @@ func rewriteValuePPC64_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32x16(v *Value) bool { +func rewriteValuePPC64_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8606,7 +8609,7 @@ func rewriteValuePPC64_OpRsh32x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32x32(v *Value) bool { +func rewriteValuePPC64_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8669,7 +8672,7 @@ func rewriteValuePPC64_OpRsh32x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32x64(v *Value) bool { +func rewriteValuePPC64_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8748,7 +8751,7 @@ func rewriteValuePPC64_OpRsh32x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh32x8(v *Value) bool { +func rewriteValuePPC64_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8775,7 +8778,7 @@ func rewriteValuePPC64_OpRsh32x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool { +func rewriteValuePPC64_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8802,7 +8805,7 @@ func rewriteValuePPC64_OpRsh64Ux16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool { +func rewriteValuePPC64_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8865,7 +8868,7 @@ func rewriteValuePPC64_OpRsh64Ux32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool { +func rewriteValuePPC64_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8942,7 +8945,7 @@ func rewriteValuePPC64_OpRsh64Ux64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool { +func rewriteValuePPC64_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8969,7 +8972,7 @@ func rewriteValuePPC64_OpRsh64Ux8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64x16(v *Value) bool { +func rewriteValuePPC64_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -8996,7 +8999,7 @@ func rewriteValuePPC64_OpRsh64x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64x32(v *Value) bool { +func rewriteValuePPC64_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9059,7 +9062,7 @@ func rewriteValuePPC64_OpRsh64x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64x64(v *Value) bool { +func rewriteValuePPC64_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9138,7 +9141,7 @@ func rewriteValuePPC64_OpRsh64x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh64x8(v *Value) bool { +func rewriteValuePPC64_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9165,7 +9168,7 @@ func rewriteValuePPC64_OpRsh64x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool { +func rewriteValuePPC64_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9194,7 +9197,7 @@ func rewriteValuePPC64_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool { +func rewriteValuePPC64_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9263,7 +9266,7 @@ func rewriteValuePPC64_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool { +func rewriteValuePPC64_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9346,7 +9349,7 @@ func rewriteValuePPC64_OpRsh8Ux64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool { +func rewriteValuePPC64_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9375,7 +9378,7 @@ func rewriteValuePPC64_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8x16(v *Value) bool { +func rewriteValuePPC64_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9404,7 +9407,7 @@ func rewriteValuePPC64_OpRsh8x16(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8x32(v *Value) bool { +func rewriteValuePPC64_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9473,7 +9476,7 @@ func rewriteValuePPC64_OpRsh8x32(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8x64(v *Value) bool { +func rewriteValuePPC64_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9560,7 +9563,7 @@ func rewriteValuePPC64_OpRsh8x64(v *Value) bool { return true } } -func rewriteValuePPC64_OpRsh8x8(v *Value) bool { +func rewriteValuePPC64_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -9589,7 +9592,7 @@ func rewriteValuePPC64_OpRsh8x8(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt16to32(v *Value) bool { +func rewriteValuePPC64_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -9600,7 +9603,7 @@ func rewriteValuePPC64_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt16to64(v *Value) bool { +func rewriteValuePPC64_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -9611,7 +9614,7 @@ func rewriteValuePPC64_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt32to64(v *Value) bool { +func rewriteValuePPC64_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -9622,7 +9625,7 @@ func rewriteValuePPC64_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt8to16(v *Value) bool { +func rewriteValuePPC64_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -9633,7 +9636,7 @@ func rewriteValuePPC64_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt8to32(v *Value) bool { +func rewriteValuePPC64_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -9644,7 +9647,7 @@ func rewriteValuePPC64_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValuePPC64_OpSignExt8to64(v *Value) bool { +func rewriteValuePPC64_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -9655,7 +9658,7 @@ func rewriteValuePPC64_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValuePPC64_OpSlicemask(v *Value) bool { +func rewriteValuePPC64_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -9672,7 +9675,7 @@ func rewriteValuePPC64_OpSlicemask(v *Value) bool { return true } } -func rewriteValuePPC64_OpSqrt(v *Value) bool { +func rewriteValuePPC64_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRT x) @@ -9683,7 +9686,7 @@ func rewriteValuePPC64_OpSqrt(v *Value) bool { return true } } -func rewriteValuePPC64_OpStaticCall(v *Value) bool { +func rewriteValuePPC64_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -9698,7 +9701,7 @@ func rewriteValuePPC64_OpStaticCall(v *Value) bool { return true } } -func rewriteValuePPC64_OpStore(v *Value) bool { +func rewriteValuePPC64_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (FMOVDstore ptr val mem) @@ -9820,7 +9823,7 @@ func rewriteValuePPC64_OpStore(v *Value) bool { } return false } -func rewriteValuePPC64_OpSub16(v *Value) bool { +func rewriteValuePPC64_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUB x y) @@ -9833,7 +9836,7 @@ func rewriteValuePPC64_OpSub16(v *Value) bool { return true } } -func rewriteValuePPC64_OpSub32(v *Value) bool { +func rewriteValuePPC64_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUB x y) @@ -9846,7 +9849,7 @@ func rewriteValuePPC64_OpSub32(v *Value) bool { return true } } -func rewriteValuePPC64_OpSub32F(v *Value) bool { +func rewriteValuePPC64_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -9859,7 +9862,7 @@ func rewriteValuePPC64_OpSub32F(v *Value) bool { return true } } -func rewriteValuePPC64_OpSub64(v *Value) bool { +func rewriteValuePPC64_OpSub64_0(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -9872,7 +9875,7 @@ func rewriteValuePPC64_OpSub64(v *Value) bool { return true } } -func rewriteValuePPC64_OpSub64F(v *Value) bool { +func rewriteValuePPC64_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUB x y) @@ -9885,7 +9888,7 @@ func rewriteValuePPC64_OpSub64F(v *Value) bool { return true } } -func rewriteValuePPC64_OpSub8(v *Value) bool { +func rewriteValuePPC64_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUB x y) @@ -9898,7 +9901,7 @@ func rewriteValuePPC64_OpSub8(v *Value) bool { return true } } -func rewriteValuePPC64_OpSubPtr(v *Value) bool { +func rewriteValuePPC64_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -9911,7 +9914,7 @@ func rewriteValuePPC64_OpSubPtr(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc16to8(v *Value) bool { +func rewriteValuePPC64_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: (MOVBreg x) @@ -9922,7 +9925,7 @@ func rewriteValuePPC64_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc32to16(v *Value) bool { +func rewriteValuePPC64_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: (MOVHreg x) @@ -9933,7 +9936,7 @@ func rewriteValuePPC64_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc32to8(v *Value) bool { +func rewriteValuePPC64_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: (MOVBreg x) @@ -9944,7 +9947,7 @@ func rewriteValuePPC64_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to16(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: (MOVHreg x) @@ -9955,7 +9958,7 @@ func rewriteValuePPC64_OpTrunc64to16(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to32(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: (MOVWreg x) @@ -9966,7 +9969,7 @@ func rewriteValuePPC64_OpTrunc64to32(v *Value) bool { return true } } -func rewriteValuePPC64_OpTrunc64to8(v *Value) bool { +func rewriteValuePPC64_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: (MOVBreg x) @@ -9977,7 +9980,7 @@ func rewriteValuePPC64_OpTrunc64to8(v *Value) bool { return true } } -func rewriteValuePPC64_OpXor16(v *Value) bool { +func rewriteValuePPC64_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XOR x y) @@ -9990,7 +9993,7 @@ func rewriteValuePPC64_OpXor16(v *Value) bool { return true } } -func rewriteValuePPC64_OpXor32(v *Value) bool { +func rewriteValuePPC64_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XOR x y) @@ -10003,7 +10006,7 @@ func rewriteValuePPC64_OpXor32(v *Value) bool { return true } } -func rewriteValuePPC64_OpXor64(v *Value) bool { +func rewriteValuePPC64_OpXor64_0(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -10016,7 +10019,7 @@ func rewriteValuePPC64_OpXor64(v *Value) bool { return true } } -func rewriteValuePPC64_OpXor8(v *Value) bool { +func rewriteValuePPC64_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XOR x y) @@ -10029,7 +10032,7 @@ func rewriteValuePPC64_OpXor8(v *Value) bool { return true } } -func rewriteValuePPC64_OpZero(v *Value) bool { +func rewriteValuePPC64_OpZero_0(v *Value) bool { b := v.Block _ = b // match: (Zero [0] _ mem) @@ -10196,6 +10199,11 @@ func rewriteValuePPC64_OpZero(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuePPC64_OpZero_10(v *Value) bool { + b := v.Block + _ = b // match: (Zero [16] destptr mem) // cond: // result: (MOVDstorezero [8] destptr (MOVDstorezero [0] destptr mem)) @@ -10384,7 +10392,7 @@ func rewriteValuePPC64_OpZero(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool { +func rewriteValuePPC64_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHZreg x) @@ -10395,7 +10403,7 @@ func rewriteValuePPC64_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool { +func rewriteValuePPC64_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHZreg x) @@ -10406,7 +10414,7 @@ func rewriteValuePPC64_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool { +func rewriteValuePPC64_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWZreg x) @@ -10417,7 +10425,7 @@ func rewriteValuePPC64_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool { +func rewriteValuePPC64_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBZreg x) @@ -10428,7 +10436,7 @@ func rewriteValuePPC64_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool { +func rewriteValuePPC64_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBZreg x) @@ -10439,7 +10447,7 @@ func rewriteValuePPC64_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValuePPC64_OpZeroExt8to64(v *Value) bool { +func rewriteValuePPC64_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBZreg x) diff --git a/src/cmd/compile/internal/ssa/rewriteS390X.go b/src/cmd/compile/internal/ssa/rewriteS390X.go index 6946e54cd8..d8e8bd70f1 100644 --- a/src/cmd/compile/internal/ssa/rewriteS390X.go +++ b/src/cmd/compile/internal/ssa/rewriteS390X.go @@ -14,713 +14,713 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValueS390X(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValueS390X_OpAdd16(v) + return rewriteValueS390X_OpAdd16_0(v) case OpAdd32: - return rewriteValueS390X_OpAdd32(v) + return rewriteValueS390X_OpAdd32_0(v) case OpAdd32F: - return rewriteValueS390X_OpAdd32F(v) + return rewriteValueS390X_OpAdd32F_0(v) case OpAdd64: - return rewriteValueS390X_OpAdd64(v) + return rewriteValueS390X_OpAdd64_0(v) case OpAdd64F: - return rewriteValueS390X_OpAdd64F(v) + return rewriteValueS390X_OpAdd64F_0(v) case OpAdd8: - return rewriteValueS390X_OpAdd8(v) + return rewriteValueS390X_OpAdd8_0(v) case OpAddPtr: - return rewriteValueS390X_OpAddPtr(v) + return rewriteValueS390X_OpAddPtr_0(v) case OpAddr: - return rewriteValueS390X_OpAddr(v) + return rewriteValueS390X_OpAddr_0(v) case OpAnd16: - return rewriteValueS390X_OpAnd16(v) + return rewriteValueS390X_OpAnd16_0(v) case OpAnd32: - return rewriteValueS390X_OpAnd32(v) + return rewriteValueS390X_OpAnd32_0(v) case OpAnd64: - return rewriteValueS390X_OpAnd64(v) + return rewriteValueS390X_OpAnd64_0(v) case OpAnd8: - return rewriteValueS390X_OpAnd8(v) + return rewriteValueS390X_OpAnd8_0(v) case OpAndB: - return rewriteValueS390X_OpAndB(v) + return rewriteValueS390X_OpAndB_0(v) case OpAtomicAdd32: - return rewriteValueS390X_OpAtomicAdd32(v) + return rewriteValueS390X_OpAtomicAdd32_0(v) case OpAtomicAdd64: - return rewriteValueS390X_OpAtomicAdd64(v) + return rewriteValueS390X_OpAtomicAdd64_0(v) case OpAtomicCompareAndSwap32: - return rewriteValueS390X_OpAtomicCompareAndSwap32(v) + return rewriteValueS390X_OpAtomicCompareAndSwap32_0(v) case OpAtomicCompareAndSwap64: - return rewriteValueS390X_OpAtomicCompareAndSwap64(v) + return rewriteValueS390X_OpAtomicCompareAndSwap64_0(v) case OpAtomicExchange32: - return rewriteValueS390X_OpAtomicExchange32(v) + return rewriteValueS390X_OpAtomicExchange32_0(v) case OpAtomicExchange64: - return rewriteValueS390X_OpAtomicExchange64(v) + return rewriteValueS390X_OpAtomicExchange64_0(v) case OpAtomicLoad32: - return rewriteValueS390X_OpAtomicLoad32(v) + return rewriteValueS390X_OpAtomicLoad32_0(v) case OpAtomicLoad64: - return rewriteValueS390X_OpAtomicLoad64(v) + return rewriteValueS390X_OpAtomicLoad64_0(v) case OpAtomicLoadPtr: - return rewriteValueS390X_OpAtomicLoadPtr(v) + return rewriteValueS390X_OpAtomicLoadPtr_0(v) case OpAtomicStore32: - return rewriteValueS390X_OpAtomicStore32(v) + return rewriteValueS390X_OpAtomicStore32_0(v) case OpAtomicStore64: - return rewriteValueS390X_OpAtomicStore64(v) + return rewriteValueS390X_OpAtomicStore64_0(v) case OpAtomicStorePtrNoWB: - return rewriteValueS390X_OpAtomicStorePtrNoWB(v) + return rewriteValueS390X_OpAtomicStorePtrNoWB_0(v) case OpAvg64u: - return rewriteValueS390X_OpAvg64u(v) + return rewriteValueS390X_OpAvg64u_0(v) case OpBitLen64: - return rewriteValueS390X_OpBitLen64(v) + return rewriteValueS390X_OpBitLen64_0(v) case OpBswap32: - return rewriteValueS390X_OpBswap32(v) + return rewriteValueS390X_OpBswap32_0(v) case OpBswap64: - return rewriteValueS390X_OpBswap64(v) + return rewriteValueS390X_OpBswap64_0(v) case OpClosureCall: - return rewriteValueS390X_OpClosureCall(v) + return rewriteValueS390X_OpClosureCall_0(v) case OpCom16: - return rewriteValueS390X_OpCom16(v) + return rewriteValueS390X_OpCom16_0(v) case OpCom32: - return rewriteValueS390X_OpCom32(v) + return rewriteValueS390X_OpCom32_0(v) case OpCom64: - return rewriteValueS390X_OpCom64(v) + return rewriteValueS390X_OpCom64_0(v) case OpCom8: - return rewriteValueS390X_OpCom8(v) + return rewriteValueS390X_OpCom8_0(v) case OpConst16: - return rewriteValueS390X_OpConst16(v) + return rewriteValueS390X_OpConst16_0(v) case OpConst32: - return rewriteValueS390X_OpConst32(v) + return rewriteValueS390X_OpConst32_0(v) case OpConst32F: - return rewriteValueS390X_OpConst32F(v) + return rewriteValueS390X_OpConst32F_0(v) case OpConst64: - return rewriteValueS390X_OpConst64(v) + return rewriteValueS390X_OpConst64_0(v) case OpConst64F: - return rewriteValueS390X_OpConst64F(v) + return rewriteValueS390X_OpConst64F_0(v) case OpConst8: - return rewriteValueS390X_OpConst8(v) + return rewriteValueS390X_OpConst8_0(v) case OpConstBool: - return rewriteValueS390X_OpConstBool(v) + return rewriteValueS390X_OpConstBool_0(v) case OpConstNil: - return rewriteValueS390X_OpConstNil(v) + return rewriteValueS390X_OpConstNil_0(v) case OpConvert: - return rewriteValueS390X_OpConvert(v) + return rewriteValueS390X_OpConvert_0(v) case OpCtz32: - return rewriteValueS390X_OpCtz32(v) + return rewriteValueS390X_OpCtz32_0(v) case OpCtz64: - return rewriteValueS390X_OpCtz64(v) + return rewriteValueS390X_OpCtz64_0(v) case OpCvt32Fto32: - return rewriteValueS390X_OpCvt32Fto32(v) + return rewriteValueS390X_OpCvt32Fto32_0(v) case OpCvt32Fto64: - return rewriteValueS390X_OpCvt32Fto64(v) + return rewriteValueS390X_OpCvt32Fto64_0(v) case OpCvt32Fto64F: - return rewriteValueS390X_OpCvt32Fto64F(v) + return rewriteValueS390X_OpCvt32Fto64F_0(v) case OpCvt32to32F: - return rewriteValueS390X_OpCvt32to32F(v) + return rewriteValueS390X_OpCvt32to32F_0(v) case OpCvt32to64F: - return rewriteValueS390X_OpCvt32to64F(v) + return rewriteValueS390X_OpCvt32to64F_0(v) case OpCvt64Fto32: - return rewriteValueS390X_OpCvt64Fto32(v) + return rewriteValueS390X_OpCvt64Fto32_0(v) case OpCvt64Fto32F: - return rewriteValueS390X_OpCvt64Fto32F(v) + return rewriteValueS390X_OpCvt64Fto32F_0(v) case OpCvt64Fto64: - return rewriteValueS390X_OpCvt64Fto64(v) + return rewriteValueS390X_OpCvt64Fto64_0(v) case OpCvt64to32F: - return rewriteValueS390X_OpCvt64to32F(v) + return rewriteValueS390X_OpCvt64to32F_0(v) case OpCvt64to64F: - return rewriteValueS390X_OpCvt64to64F(v) + return rewriteValueS390X_OpCvt64to64F_0(v) case OpDiv16: - return rewriteValueS390X_OpDiv16(v) + return rewriteValueS390X_OpDiv16_0(v) case OpDiv16u: - return rewriteValueS390X_OpDiv16u(v) + return rewriteValueS390X_OpDiv16u_0(v) case OpDiv32: - return rewriteValueS390X_OpDiv32(v) + return rewriteValueS390X_OpDiv32_0(v) case OpDiv32F: - return rewriteValueS390X_OpDiv32F(v) + return rewriteValueS390X_OpDiv32F_0(v) case OpDiv32u: - return rewriteValueS390X_OpDiv32u(v) + return rewriteValueS390X_OpDiv32u_0(v) case OpDiv64: - return rewriteValueS390X_OpDiv64(v) + return rewriteValueS390X_OpDiv64_0(v) case OpDiv64F: - return rewriteValueS390X_OpDiv64F(v) + return rewriteValueS390X_OpDiv64F_0(v) case OpDiv64u: - return rewriteValueS390X_OpDiv64u(v) + return rewriteValueS390X_OpDiv64u_0(v) case OpDiv8: - return rewriteValueS390X_OpDiv8(v) + return rewriteValueS390X_OpDiv8_0(v) case OpDiv8u: - return rewriteValueS390X_OpDiv8u(v) + return rewriteValueS390X_OpDiv8u_0(v) case OpEq16: - return rewriteValueS390X_OpEq16(v) + return rewriteValueS390X_OpEq16_0(v) case OpEq32: - return rewriteValueS390X_OpEq32(v) + return rewriteValueS390X_OpEq32_0(v) case OpEq32F: - return rewriteValueS390X_OpEq32F(v) + return rewriteValueS390X_OpEq32F_0(v) case OpEq64: - return rewriteValueS390X_OpEq64(v) + return rewriteValueS390X_OpEq64_0(v) case OpEq64F: - return rewriteValueS390X_OpEq64F(v) + return rewriteValueS390X_OpEq64F_0(v) case OpEq8: - return rewriteValueS390X_OpEq8(v) + return rewriteValueS390X_OpEq8_0(v) case OpEqB: - return rewriteValueS390X_OpEqB(v) + return rewriteValueS390X_OpEqB_0(v) case OpEqPtr: - return rewriteValueS390X_OpEqPtr(v) + return rewriteValueS390X_OpEqPtr_0(v) case OpGeq16: - return rewriteValueS390X_OpGeq16(v) + return rewriteValueS390X_OpGeq16_0(v) case OpGeq16U: - return rewriteValueS390X_OpGeq16U(v) + return rewriteValueS390X_OpGeq16U_0(v) case OpGeq32: - return rewriteValueS390X_OpGeq32(v) + return rewriteValueS390X_OpGeq32_0(v) case OpGeq32F: - return rewriteValueS390X_OpGeq32F(v) + return rewriteValueS390X_OpGeq32F_0(v) case OpGeq32U: - return rewriteValueS390X_OpGeq32U(v) + return rewriteValueS390X_OpGeq32U_0(v) case OpGeq64: - return rewriteValueS390X_OpGeq64(v) + return rewriteValueS390X_OpGeq64_0(v) case OpGeq64F: - return rewriteValueS390X_OpGeq64F(v) + return rewriteValueS390X_OpGeq64F_0(v) case OpGeq64U: - return rewriteValueS390X_OpGeq64U(v) + return rewriteValueS390X_OpGeq64U_0(v) case OpGeq8: - return rewriteValueS390X_OpGeq8(v) + return rewriteValueS390X_OpGeq8_0(v) case OpGeq8U: - return rewriteValueS390X_OpGeq8U(v) + return rewriteValueS390X_OpGeq8U_0(v) case OpGetClosurePtr: - return rewriteValueS390X_OpGetClosurePtr(v) + return rewriteValueS390X_OpGetClosurePtr_0(v) case OpGetG: - return rewriteValueS390X_OpGetG(v) + return rewriteValueS390X_OpGetG_0(v) case OpGreater16: - return rewriteValueS390X_OpGreater16(v) + return rewriteValueS390X_OpGreater16_0(v) case OpGreater16U: - return rewriteValueS390X_OpGreater16U(v) + return rewriteValueS390X_OpGreater16U_0(v) case OpGreater32: - return rewriteValueS390X_OpGreater32(v) + return rewriteValueS390X_OpGreater32_0(v) case OpGreater32F: - return rewriteValueS390X_OpGreater32F(v) + return rewriteValueS390X_OpGreater32F_0(v) case OpGreater32U: - return rewriteValueS390X_OpGreater32U(v) + return rewriteValueS390X_OpGreater32U_0(v) case OpGreater64: - return rewriteValueS390X_OpGreater64(v) + return rewriteValueS390X_OpGreater64_0(v) case OpGreater64F: - return rewriteValueS390X_OpGreater64F(v) + return rewriteValueS390X_OpGreater64F_0(v) case OpGreater64U: - return rewriteValueS390X_OpGreater64U(v) + return rewriteValueS390X_OpGreater64U_0(v) case OpGreater8: - return rewriteValueS390X_OpGreater8(v) + return rewriteValueS390X_OpGreater8_0(v) case OpGreater8U: - return rewriteValueS390X_OpGreater8U(v) + return rewriteValueS390X_OpGreater8U_0(v) case OpHmul32: - return rewriteValueS390X_OpHmul32(v) + return rewriteValueS390X_OpHmul32_0(v) case OpHmul32u: - return rewriteValueS390X_OpHmul32u(v) + return rewriteValueS390X_OpHmul32u_0(v) case OpHmul64: - return rewriteValueS390X_OpHmul64(v) + return rewriteValueS390X_OpHmul64_0(v) case OpHmul64u: - return rewriteValueS390X_OpHmul64u(v) + return rewriteValueS390X_OpHmul64u_0(v) case OpITab: - return rewriteValueS390X_OpITab(v) + return rewriteValueS390X_OpITab_0(v) case OpInterCall: - return rewriteValueS390X_OpInterCall(v) + return rewriteValueS390X_OpInterCall_0(v) case OpIsInBounds: - return rewriteValueS390X_OpIsInBounds(v) + return rewriteValueS390X_OpIsInBounds_0(v) case OpIsNonNil: - return rewriteValueS390X_OpIsNonNil(v) + return rewriteValueS390X_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValueS390X_OpIsSliceInBounds(v) + return rewriteValueS390X_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValueS390X_OpLeq16(v) + return rewriteValueS390X_OpLeq16_0(v) case OpLeq16U: - return rewriteValueS390X_OpLeq16U(v) + return rewriteValueS390X_OpLeq16U_0(v) case OpLeq32: - return rewriteValueS390X_OpLeq32(v) + return rewriteValueS390X_OpLeq32_0(v) case OpLeq32F: - return rewriteValueS390X_OpLeq32F(v) + return rewriteValueS390X_OpLeq32F_0(v) case OpLeq32U: - return rewriteValueS390X_OpLeq32U(v) + return rewriteValueS390X_OpLeq32U_0(v) case OpLeq64: - return rewriteValueS390X_OpLeq64(v) + return rewriteValueS390X_OpLeq64_0(v) case OpLeq64F: - return rewriteValueS390X_OpLeq64F(v) + return rewriteValueS390X_OpLeq64F_0(v) case OpLeq64U: - return rewriteValueS390X_OpLeq64U(v) + return rewriteValueS390X_OpLeq64U_0(v) case OpLeq8: - return rewriteValueS390X_OpLeq8(v) + return rewriteValueS390X_OpLeq8_0(v) case OpLeq8U: - return rewriteValueS390X_OpLeq8U(v) + return rewriteValueS390X_OpLeq8U_0(v) case OpLess16: - return rewriteValueS390X_OpLess16(v) + return rewriteValueS390X_OpLess16_0(v) case OpLess16U: - return rewriteValueS390X_OpLess16U(v) + return rewriteValueS390X_OpLess16U_0(v) case OpLess32: - return rewriteValueS390X_OpLess32(v) + return rewriteValueS390X_OpLess32_0(v) case OpLess32F: - return rewriteValueS390X_OpLess32F(v) + return rewriteValueS390X_OpLess32F_0(v) case OpLess32U: - return rewriteValueS390X_OpLess32U(v) + return rewriteValueS390X_OpLess32U_0(v) case OpLess64: - return rewriteValueS390X_OpLess64(v) + return rewriteValueS390X_OpLess64_0(v) case OpLess64F: - return rewriteValueS390X_OpLess64F(v) + return rewriteValueS390X_OpLess64F_0(v) case OpLess64U: - return rewriteValueS390X_OpLess64U(v) + return rewriteValueS390X_OpLess64U_0(v) case OpLess8: - return rewriteValueS390X_OpLess8(v) + return rewriteValueS390X_OpLess8_0(v) case OpLess8U: - return rewriteValueS390X_OpLess8U(v) + return rewriteValueS390X_OpLess8U_0(v) case OpLoad: - return rewriteValueS390X_OpLoad(v) + return rewriteValueS390X_OpLoad_0(v) case OpLsh16x16: - return rewriteValueS390X_OpLsh16x16(v) + return rewriteValueS390X_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValueS390X_OpLsh16x32(v) + return rewriteValueS390X_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValueS390X_OpLsh16x64(v) + return rewriteValueS390X_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValueS390X_OpLsh16x8(v) + return rewriteValueS390X_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValueS390X_OpLsh32x16(v) + return rewriteValueS390X_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValueS390X_OpLsh32x32(v) + return rewriteValueS390X_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValueS390X_OpLsh32x64(v) + return rewriteValueS390X_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValueS390X_OpLsh32x8(v) + return rewriteValueS390X_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValueS390X_OpLsh64x16(v) + return rewriteValueS390X_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValueS390X_OpLsh64x32(v) + return rewriteValueS390X_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValueS390X_OpLsh64x64(v) + return rewriteValueS390X_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValueS390X_OpLsh64x8(v) + return rewriteValueS390X_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValueS390X_OpLsh8x16(v) + return rewriteValueS390X_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValueS390X_OpLsh8x32(v) + return rewriteValueS390X_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValueS390X_OpLsh8x64(v) + return rewriteValueS390X_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValueS390X_OpLsh8x8(v) + return rewriteValueS390X_OpLsh8x8_0(v) case OpMod16: - return rewriteValueS390X_OpMod16(v) + return rewriteValueS390X_OpMod16_0(v) case OpMod16u: - return rewriteValueS390X_OpMod16u(v) + return rewriteValueS390X_OpMod16u_0(v) case OpMod32: - return rewriteValueS390X_OpMod32(v) + return rewriteValueS390X_OpMod32_0(v) case OpMod32u: - return rewriteValueS390X_OpMod32u(v) + return rewriteValueS390X_OpMod32u_0(v) case OpMod64: - return rewriteValueS390X_OpMod64(v) + return rewriteValueS390X_OpMod64_0(v) case OpMod64u: - return rewriteValueS390X_OpMod64u(v) + return rewriteValueS390X_OpMod64u_0(v) case OpMod8: - return rewriteValueS390X_OpMod8(v) + return rewriteValueS390X_OpMod8_0(v) case OpMod8u: - return rewriteValueS390X_OpMod8u(v) + return rewriteValueS390X_OpMod8u_0(v) case OpMove: - return rewriteValueS390X_OpMove(v) + return rewriteValueS390X_OpMove_0(v) || rewriteValueS390X_OpMove_10(v) case OpMul16: - return rewriteValueS390X_OpMul16(v) + return rewriteValueS390X_OpMul16_0(v) case OpMul32: - return rewriteValueS390X_OpMul32(v) + return rewriteValueS390X_OpMul32_0(v) case OpMul32F: - return rewriteValueS390X_OpMul32F(v) + return rewriteValueS390X_OpMul32F_0(v) case OpMul64: - return rewriteValueS390X_OpMul64(v) + return rewriteValueS390X_OpMul64_0(v) case OpMul64F: - return rewriteValueS390X_OpMul64F(v) + return rewriteValueS390X_OpMul64F_0(v) case OpMul8: - return rewriteValueS390X_OpMul8(v) + return rewriteValueS390X_OpMul8_0(v) case OpNeg16: - return rewriteValueS390X_OpNeg16(v) + return rewriteValueS390X_OpNeg16_0(v) case OpNeg32: - return rewriteValueS390X_OpNeg32(v) + return rewriteValueS390X_OpNeg32_0(v) case OpNeg32F: - return rewriteValueS390X_OpNeg32F(v) + return rewriteValueS390X_OpNeg32F_0(v) case OpNeg64: - return rewriteValueS390X_OpNeg64(v) + return rewriteValueS390X_OpNeg64_0(v) case OpNeg64F: - return rewriteValueS390X_OpNeg64F(v) + return rewriteValueS390X_OpNeg64F_0(v) case OpNeg8: - return rewriteValueS390X_OpNeg8(v) + return rewriteValueS390X_OpNeg8_0(v) case OpNeq16: - return rewriteValueS390X_OpNeq16(v) + return rewriteValueS390X_OpNeq16_0(v) case OpNeq32: - return rewriteValueS390X_OpNeq32(v) + return rewriteValueS390X_OpNeq32_0(v) case OpNeq32F: - return rewriteValueS390X_OpNeq32F(v) + return rewriteValueS390X_OpNeq32F_0(v) case OpNeq64: - return rewriteValueS390X_OpNeq64(v) + return rewriteValueS390X_OpNeq64_0(v) case OpNeq64F: - return rewriteValueS390X_OpNeq64F(v) + return rewriteValueS390X_OpNeq64F_0(v) case OpNeq8: - return rewriteValueS390X_OpNeq8(v) + return rewriteValueS390X_OpNeq8_0(v) case OpNeqB: - return rewriteValueS390X_OpNeqB(v) + return rewriteValueS390X_OpNeqB_0(v) case OpNeqPtr: - return rewriteValueS390X_OpNeqPtr(v) + return rewriteValueS390X_OpNeqPtr_0(v) case OpNilCheck: - return rewriteValueS390X_OpNilCheck(v) + return rewriteValueS390X_OpNilCheck_0(v) case OpNot: - return rewriteValueS390X_OpNot(v) + return rewriteValueS390X_OpNot_0(v) case OpOffPtr: - return rewriteValueS390X_OpOffPtr(v) + return rewriteValueS390X_OpOffPtr_0(v) case OpOr16: - return rewriteValueS390X_OpOr16(v) + return rewriteValueS390X_OpOr16_0(v) case OpOr32: - return rewriteValueS390X_OpOr32(v) + return rewriteValueS390X_OpOr32_0(v) case OpOr64: - return rewriteValueS390X_OpOr64(v) + return rewriteValueS390X_OpOr64_0(v) case OpOr8: - return rewriteValueS390X_OpOr8(v) + return rewriteValueS390X_OpOr8_0(v) case OpOrB: - return rewriteValueS390X_OpOrB(v) + return rewriteValueS390X_OpOrB_0(v) case OpRound32F: - return rewriteValueS390X_OpRound32F(v) + return rewriteValueS390X_OpRound32F_0(v) case OpRound64F: - return rewriteValueS390X_OpRound64F(v) + return rewriteValueS390X_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValueS390X_OpRsh16Ux16(v) + return rewriteValueS390X_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValueS390X_OpRsh16Ux32(v) + return rewriteValueS390X_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValueS390X_OpRsh16Ux64(v) + return rewriteValueS390X_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValueS390X_OpRsh16Ux8(v) + return rewriteValueS390X_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValueS390X_OpRsh16x16(v) + return rewriteValueS390X_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValueS390X_OpRsh16x32(v) + return rewriteValueS390X_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValueS390X_OpRsh16x64(v) + return rewriteValueS390X_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValueS390X_OpRsh16x8(v) + return rewriteValueS390X_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValueS390X_OpRsh32Ux16(v) + return rewriteValueS390X_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValueS390X_OpRsh32Ux32(v) + return rewriteValueS390X_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValueS390X_OpRsh32Ux64(v) + return rewriteValueS390X_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValueS390X_OpRsh32Ux8(v) + return rewriteValueS390X_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValueS390X_OpRsh32x16(v) + return rewriteValueS390X_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValueS390X_OpRsh32x32(v) + return rewriteValueS390X_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValueS390X_OpRsh32x64(v) + return rewriteValueS390X_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValueS390X_OpRsh32x8(v) + return rewriteValueS390X_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValueS390X_OpRsh64Ux16(v) + return rewriteValueS390X_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValueS390X_OpRsh64Ux32(v) + return rewriteValueS390X_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValueS390X_OpRsh64Ux64(v) + return rewriteValueS390X_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValueS390X_OpRsh64Ux8(v) + return rewriteValueS390X_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValueS390X_OpRsh64x16(v) + return rewriteValueS390X_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValueS390X_OpRsh64x32(v) + return rewriteValueS390X_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValueS390X_OpRsh64x64(v) + return rewriteValueS390X_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValueS390X_OpRsh64x8(v) + return rewriteValueS390X_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValueS390X_OpRsh8Ux16(v) + return rewriteValueS390X_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValueS390X_OpRsh8Ux32(v) + return rewriteValueS390X_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValueS390X_OpRsh8Ux64(v) + return rewriteValueS390X_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValueS390X_OpRsh8Ux8(v) + return rewriteValueS390X_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValueS390X_OpRsh8x16(v) + return rewriteValueS390X_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValueS390X_OpRsh8x32(v) + return rewriteValueS390X_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValueS390X_OpRsh8x64(v) + return rewriteValueS390X_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValueS390X_OpRsh8x8(v) + return rewriteValueS390X_OpRsh8x8_0(v) case OpS390XADD: - return rewriteValueS390X_OpS390XADD(v) + return rewriteValueS390X_OpS390XADD_0(v) || rewriteValueS390X_OpS390XADD_10(v) case OpS390XADDW: - return rewriteValueS390X_OpS390XADDW(v) + return rewriteValueS390X_OpS390XADDW_0(v) || rewriteValueS390X_OpS390XADDW_10(v) case OpS390XADDWconst: - return rewriteValueS390X_OpS390XADDWconst(v) + return rewriteValueS390X_OpS390XADDWconst_0(v) case OpS390XADDconst: - return rewriteValueS390X_OpS390XADDconst(v) + return rewriteValueS390X_OpS390XADDconst_0(v) case OpS390XAND: - return rewriteValueS390X_OpS390XAND(v) + return rewriteValueS390X_OpS390XAND_0(v) || rewriteValueS390X_OpS390XAND_10(v) case OpS390XANDW: - return rewriteValueS390X_OpS390XANDW(v) + return rewriteValueS390X_OpS390XANDW_0(v) || rewriteValueS390X_OpS390XANDW_10(v) case OpS390XANDWconst: - return rewriteValueS390X_OpS390XANDWconst(v) + return rewriteValueS390X_OpS390XANDWconst_0(v) case OpS390XANDconst: - return rewriteValueS390X_OpS390XANDconst(v) + return rewriteValueS390X_OpS390XANDconst_0(v) case OpS390XCMP: - return rewriteValueS390X_OpS390XCMP(v) + return rewriteValueS390X_OpS390XCMP_0(v) case OpS390XCMPU: - return rewriteValueS390X_OpS390XCMPU(v) + return rewriteValueS390X_OpS390XCMPU_0(v) case OpS390XCMPUconst: - return rewriteValueS390X_OpS390XCMPUconst(v) + return rewriteValueS390X_OpS390XCMPUconst_0(v) case OpS390XCMPW: - return rewriteValueS390X_OpS390XCMPW(v) + return rewriteValueS390X_OpS390XCMPW_0(v) case OpS390XCMPWU: - return rewriteValueS390X_OpS390XCMPWU(v) + return rewriteValueS390X_OpS390XCMPWU_0(v) case OpS390XCMPWUconst: - return rewriteValueS390X_OpS390XCMPWUconst(v) + return rewriteValueS390X_OpS390XCMPWUconst_0(v) case OpS390XCMPWconst: - return rewriteValueS390X_OpS390XCMPWconst(v) + return rewriteValueS390X_OpS390XCMPWconst_0(v) case OpS390XCMPconst: - return rewriteValueS390X_OpS390XCMPconst(v) + return rewriteValueS390X_OpS390XCMPconst_0(v) case OpS390XFADD: - return rewriteValueS390X_OpS390XFADD(v) + return rewriteValueS390X_OpS390XFADD_0(v) case OpS390XFADDS: - return rewriteValueS390X_OpS390XFADDS(v) + return rewriteValueS390X_OpS390XFADDS_0(v) case OpS390XFMOVDload: - return rewriteValueS390X_OpS390XFMOVDload(v) + return rewriteValueS390X_OpS390XFMOVDload_0(v) case OpS390XFMOVDloadidx: - return rewriteValueS390X_OpS390XFMOVDloadidx(v) + return rewriteValueS390X_OpS390XFMOVDloadidx_0(v) case OpS390XFMOVDstore: - return rewriteValueS390X_OpS390XFMOVDstore(v) + return rewriteValueS390X_OpS390XFMOVDstore_0(v) case OpS390XFMOVDstoreidx: - return rewriteValueS390X_OpS390XFMOVDstoreidx(v) + return rewriteValueS390X_OpS390XFMOVDstoreidx_0(v) case OpS390XFMOVSload: - return rewriteValueS390X_OpS390XFMOVSload(v) + return rewriteValueS390X_OpS390XFMOVSload_0(v) case OpS390XFMOVSloadidx: - return rewriteValueS390X_OpS390XFMOVSloadidx(v) + return rewriteValueS390X_OpS390XFMOVSloadidx_0(v) case OpS390XFMOVSstore: - return rewriteValueS390X_OpS390XFMOVSstore(v) + return rewriteValueS390X_OpS390XFMOVSstore_0(v) case OpS390XFMOVSstoreidx: - return rewriteValueS390X_OpS390XFMOVSstoreidx(v) + return rewriteValueS390X_OpS390XFMOVSstoreidx_0(v) case OpS390XFSUB: - return rewriteValueS390X_OpS390XFSUB(v) + return rewriteValueS390X_OpS390XFSUB_0(v) case OpS390XFSUBS: - return rewriteValueS390X_OpS390XFSUBS(v) + return rewriteValueS390X_OpS390XFSUBS_0(v) case OpS390XLoweredRound32F: - return rewriteValueS390X_OpS390XLoweredRound32F(v) + return rewriteValueS390X_OpS390XLoweredRound32F_0(v) case OpS390XLoweredRound64F: - return rewriteValueS390X_OpS390XLoweredRound64F(v) + return rewriteValueS390X_OpS390XLoweredRound64F_0(v) case OpS390XMOVBZload: - return rewriteValueS390X_OpS390XMOVBZload(v) + return rewriteValueS390X_OpS390XMOVBZload_0(v) case OpS390XMOVBZloadidx: - return rewriteValueS390X_OpS390XMOVBZloadidx(v) + return rewriteValueS390X_OpS390XMOVBZloadidx_0(v) case OpS390XMOVBZreg: - return rewriteValueS390X_OpS390XMOVBZreg(v) + return rewriteValueS390X_OpS390XMOVBZreg_0(v) || rewriteValueS390X_OpS390XMOVBZreg_10(v) case OpS390XMOVBload: - return rewriteValueS390X_OpS390XMOVBload(v) + return rewriteValueS390X_OpS390XMOVBload_0(v) case OpS390XMOVBreg: - return rewriteValueS390X_OpS390XMOVBreg(v) + return rewriteValueS390X_OpS390XMOVBreg_0(v) case OpS390XMOVBstore: - return rewriteValueS390X_OpS390XMOVBstore(v) + return rewriteValueS390X_OpS390XMOVBstore_0(v) || rewriteValueS390X_OpS390XMOVBstore_10(v) case OpS390XMOVBstoreconst: - return rewriteValueS390X_OpS390XMOVBstoreconst(v) + return rewriteValueS390X_OpS390XMOVBstoreconst_0(v) case OpS390XMOVBstoreidx: - return rewriteValueS390X_OpS390XMOVBstoreidx(v) + return rewriteValueS390X_OpS390XMOVBstoreidx_0(v) || rewriteValueS390X_OpS390XMOVBstoreidx_10(v) || rewriteValueS390X_OpS390XMOVBstoreidx_20(v) || rewriteValueS390X_OpS390XMOVBstoreidx_30(v) case OpS390XMOVDEQ: - return rewriteValueS390X_OpS390XMOVDEQ(v) + return rewriteValueS390X_OpS390XMOVDEQ_0(v) case OpS390XMOVDGE: - return rewriteValueS390X_OpS390XMOVDGE(v) + return rewriteValueS390X_OpS390XMOVDGE_0(v) case OpS390XMOVDGT: - return rewriteValueS390X_OpS390XMOVDGT(v) + return rewriteValueS390X_OpS390XMOVDGT_0(v) case OpS390XMOVDLE: - return rewriteValueS390X_OpS390XMOVDLE(v) + return rewriteValueS390X_OpS390XMOVDLE_0(v) case OpS390XMOVDLT: - return rewriteValueS390X_OpS390XMOVDLT(v) + return rewriteValueS390X_OpS390XMOVDLT_0(v) case OpS390XMOVDNE: - return rewriteValueS390X_OpS390XMOVDNE(v) + return rewriteValueS390X_OpS390XMOVDNE_0(v) case OpS390XMOVDaddridx: - return rewriteValueS390X_OpS390XMOVDaddridx(v) + return rewriteValueS390X_OpS390XMOVDaddridx_0(v) case OpS390XMOVDload: - return rewriteValueS390X_OpS390XMOVDload(v) + return rewriteValueS390X_OpS390XMOVDload_0(v) case OpS390XMOVDloadidx: - return rewriteValueS390X_OpS390XMOVDloadidx(v) + return rewriteValueS390X_OpS390XMOVDloadidx_0(v) case OpS390XMOVDnop: - return rewriteValueS390X_OpS390XMOVDnop(v) + return rewriteValueS390X_OpS390XMOVDnop_0(v) || rewriteValueS390X_OpS390XMOVDnop_10(v) case OpS390XMOVDreg: - return rewriteValueS390X_OpS390XMOVDreg(v) + return rewriteValueS390X_OpS390XMOVDreg_0(v) || rewriteValueS390X_OpS390XMOVDreg_10(v) case OpS390XMOVDstore: - return rewriteValueS390X_OpS390XMOVDstore(v) + return rewriteValueS390X_OpS390XMOVDstore_0(v) case OpS390XMOVDstoreconst: - return rewriteValueS390X_OpS390XMOVDstoreconst(v) + return rewriteValueS390X_OpS390XMOVDstoreconst_0(v) case OpS390XMOVDstoreidx: - return rewriteValueS390X_OpS390XMOVDstoreidx(v) + return rewriteValueS390X_OpS390XMOVDstoreidx_0(v) case OpS390XMOVHBRstore: - return rewriteValueS390X_OpS390XMOVHBRstore(v) + return rewriteValueS390X_OpS390XMOVHBRstore_0(v) case OpS390XMOVHBRstoreidx: - return rewriteValueS390X_OpS390XMOVHBRstoreidx(v) + return rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v) case OpS390XMOVHZload: - return rewriteValueS390X_OpS390XMOVHZload(v) + return rewriteValueS390X_OpS390XMOVHZload_0(v) case OpS390XMOVHZloadidx: - return rewriteValueS390X_OpS390XMOVHZloadidx(v) + return rewriteValueS390X_OpS390XMOVHZloadidx_0(v) case OpS390XMOVHZreg: - return rewriteValueS390X_OpS390XMOVHZreg(v) + return rewriteValueS390X_OpS390XMOVHZreg_0(v) case OpS390XMOVHload: - return rewriteValueS390X_OpS390XMOVHload(v) + return rewriteValueS390X_OpS390XMOVHload_0(v) case OpS390XMOVHreg: - return rewriteValueS390X_OpS390XMOVHreg(v) + return rewriteValueS390X_OpS390XMOVHreg_0(v) case OpS390XMOVHstore: - return rewriteValueS390X_OpS390XMOVHstore(v) + return rewriteValueS390X_OpS390XMOVHstore_0(v) || rewriteValueS390X_OpS390XMOVHstore_10(v) case OpS390XMOVHstoreconst: - return rewriteValueS390X_OpS390XMOVHstoreconst(v) + return rewriteValueS390X_OpS390XMOVHstoreconst_0(v) case OpS390XMOVHstoreidx: - return rewriteValueS390X_OpS390XMOVHstoreidx(v) + return rewriteValueS390X_OpS390XMOVHstoreidx_0(v) || rewriteValueS390X_OpS390XMOVHstoreidx_10(v) case OpS390XMOVWBRstore: - return rewriteValueS390X_OpS390XMOVWBRstore(v) + return rewriteValueS390X_OpS390XMOVWBRstore_0(v) case OpS390XMOVWBRstoreidx: - return rewriteValueS390X_OpS390XMOVWBRstoreidx(v) + return rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v) case OpS390XMOVWZload: - return rewriteValueS390X_OpS390XMOVWZload(v) + return rewriteValueS390X_OpS390XMOVWZload_0(v) case OpS390XMOVWZloadidx: - return rewriteValueS390X_OpS390XMOVWZloadidx(v) + return rewriteValueS390X_OpS390XMOVWZloadidx_0(v) case OpS390XMOVWZreg: - return rewriteValueS390X_OpS390XMOVWZreg(v) + return rewriteValueS390X_OpS390XMOVWZreg_0(v) case OpS390XMOVWload: - return rewriteValueS390X_OpS390XMOVWload(v) + return rewriteValueS390X_OpS390XMOVWload_0(v) case OpS390XMOVWreg: - return rewriteValueS390X_OpS390XMOVWreg(v) + return rewriteValueS390X_OpS390XMOVWreg_0(v) || rewriteValueS390X_OpS390XMOVWreg_10(v) case OpS390XMOVWstore: - return rewriteValueS390X_OpS390XMOVWstore(v) + return rewriteValueS390X_OpS390XMOVWstore_0(v) || rewriteValueS390X_OpS390XMOVWstore_10(v) case OpS390XMOVWstoreconst: - return rewriteValueS390X_OpS390XMOVWstoreconst(v) + return rewriteValueS390X_OpS390XMOVWstoreconst_0(v) case OpS390XMOVWstoreidx: - return rewriteValueS390X_OpS390XMOVWstoreidx(v) + return rewriteValueS390X_OpS390XMOVWstoreidx_0(v) || rewriteValueS390X_OpS390XMOVWstoreidx_10(v) case OpS390XMULLD: - return rewriteValueS390X_OpS390XMULLD(v) + return rewriteValueS390X_OpS390XMULLD_0(v) case OpS390XMULLDconst: - return rewriteValueS390X_OpS390XMULLDconst(v) + return rewriteValueS390X_OpS390XMULLDconst_0(v) case OpS390XMULLW: - return rewriteValueS390X_OpS390XMULLW(v) + return rewriteValueS390X_OpS390XMULLW_0(v) case OpS390XMULLWconst: - return rewriteValueS390X_OpS390XMULLWconst(v) + return rewriteValueS390X_OpS390XMULLWconst_0(v) case OpS390XNEG: - return rewriteValueS390X_OpS390XNEG(v) + return rewriteValueS390X_OpS390XNEG_0(v) case OpS390XNEGW: - return rewriteValueS390X_OpS390XNEGW(v) + return rewriteValueS390X_OpS390XNEGW_0(v) case OpS390XNOT: - return rewriteValueS390X_OpS390XNOT(v) + return rewriteValueS390X_OpS390XNOT_0(v) case OpS390XNOTW: - return rewriteValueS390X_OpS390XNOTW(v) + return rewriteValueS390X_OpS390XNOTW_0(v) case OpS390XOR: - return rewriteValueS390X_OpS390XOR(v) + return rewriteValueS390X_OpS390XOR_0(v) || rewriteValueS390X_OpS390XOR_10(v) || rewriteValueS390X_OpS390XOR_20(v) || rewriteValueS390X_OpS390XOR_30(v) || rewriteValueS390X_OpS390XOR_40(v) || rewriteValueS390X_OpS390XOR_50(v) || rewriteValueS390X_OpS390XOR_60(v) || rewriteValueS390X_OpS390XOR_70(v) || rewriteValueS390X_OpS390XOR_80(v) || rewriteValueS390X_OpS390XOR_90(v) || rewriteValueS390X_OpS390XOR_100(v) || rewriteValueS390X_OpS390XOR_110(v) || rewriteValueS390X_OpS390XOR_120(v) || rewriteValueS390X_OpS390XOR_130(v) || rewriteValueS390X_OpS390XOR_140(v) || rewriteValueS390X_OpS390XOR_150(v) case OpS390XORW: - return rewriteValueS390X_OpS390XORW(v) + return rewriteValueS390X_OpS390XORW_0(v) || rewriteValueS390X_OpS390XORW_10(v) || rewriteValueS390X_OpS390XORW_20(v) || rewriteValueS390X_OpS390XORW_30(v) || rewriteValueS390X_OpS390XORW_40(v) || rewriteValueS390X_OpS390XORW_50(v) || rewriteValueS390X_OpS390XORW_60(v) || rewriteValueS390X_OpS390XORW_70(v) || rewriteValueS390X_OpS390XORW_80(v) || rewriteValueS390X_OpS390XORW_90(v) case OpS390XORWconst: - return rewriteValueS390X_OpS390XORWconst(v) + return rewriteValueS390X_OpS390XORWconst_0(v) case OpS390XORconst: - return rewriteValueS390X_OpS390XORconst(v) + return rewriteValueS390X_OpS390XORconst_0(v) case OpS390XSLD: - return rewriteValueS390X_OpS390XSLD(v) + return rewriteValueS390X_OpS390XSLD_0(v) case OpS390XSLW: - return rewriteValueS390X_OpS390XSLW(v) + return rewriteValueS390X_OpS390XSLW_0(v) case OpS390XSRAD: - return rewriteValueS390X_OpS390XSRAD(v) + return rewriteValueS390X_OpS390XSRAD_0(v) case OpS390XSRADconst: - return rewriteValueS390X_OpS390XSRADconst(v) + return rewriteValueS390X_OpS390XSRADconst_0(v) case OpS390XSRAW: - return rewriteValueS390X_OpS390XSRAW(v) + return rewriteValueS390X_OpS390XSRAW_0(v) case OpS390XSRAWconst: - return rewriteValueS390X_OpS390XSRAWconst(v) + return rewriteValueS390X_OpS390XSRAWconst_0(v) case OpS390XSRD: - return rewriteValueS390X_OpS390XSRD(v) + return rewriteValueS390X_OpS390XSRD_0(v) case OpS390XSRW: - return rewriteValueS390X_OpS390XSRW(v) + return rewriteValueS390X_OpS390XSRW_0(v) case OpS390XSTM2: - return rewriteValueS390X_OpS390XSTM2(v) + return rewriteValueS390X_OpS390XSTM2_0(v) case OpS390XSTMG2: - return rewriteValueS390X_OpS390XSTMG2(v) + return rewriteValueS390X_OpS390XSTMG2_0(v) case OpS390XSUB: - return rewriteValueS390X_OpS390XSUB(v) + return rewriteValueS390X_OpS390XSUB_0(v) case OpS390XSUBEWcarrymask: - return rewriteValueS390X_OpS390XSUBEWcarrymask(v) + return rewriteValueS390X_OpS390XSUBEWcarrymask_0(v) case OpS390XSUBEcarrymask: - return rewriteValueS390X_OpS390XSUBEcarrymask(v) + return rewriteValueS390X_OpS390XSUBEcarrymask_0(v) case OpS390XSUBW: - return rewriteValueS390X_OpS390XSUBW(v) + return rewriteValueS390X_OpS390XSUBW_0(v) case OpS390XSUBWconst: - return rewriteValueS390X_OpS390XSUBWconst(v) + return rewriteValueS390X_OpS390XSUBWconst_0(v) case OpS390XSUBconst: - return rewriteValueS390X_OpS390XSUBconst(v) + return rewriteValueS390X_OpS390XSUBconst_0(v) case OpS390XXOR: - return rewriteValueS390X_OpS390XXOR(v) + return rewriteValueS390X_OpS390XXOR_0(v) || rewriteValueS390X_OpS390XXOR_10(v) case OpS390XXORW: - return rewriteValueS390X_OpS390XXORW(v) + return rewriteValueS390X_OpS390XXORW_0(v) || rewriteValueS390X_OpS390XXORW_10(v) case OpS390XXORWconst: - return rewriteValueS390X_OpS390XXORWconst(v) + return rewriteValueS390X_OpS390XXORWconst_0(v) case OpS390XXORconst: - return rewriteValueS390X_OpS390XXORconst(v) + return rewriteValueS390X_OpS390XXORconst_0(v) case OpSelect0: - return rewriteValueS390X_OpSelect0(v) + return rewriteValueS390X_OpSelect0_0(v) case OpSelect1: - return rewriteValueS390X_OpSelect1(v) + return rewriteValueS390X_OpSelect1_0(v) case OpSignExt16to32: - return rewriteValueS390X_OpSignExt16to32(v) + return rewriteValueS390X_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValueS390X_OpSignExt16to64(v) + return rewriteValueS390X_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValueS390X_OpSignExt32to64(v) + return rewriteValueS390X_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValueS390X_OpSignExt8to16(v) + return rewriteValueS390X_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValueS390X_OpSignExt8to32(v) + return rewriteValueS390X_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValueS390X_OpSignExt8to64(v) + return rewriteValueS390X_OpSignExt8to64_0(v) case OpSlicemask: - return rewriteValueS390X_OpSlicemask(v) + return rewriteValueS390X_OpSlicemask_0(v) case OpSqrt: - return rewriteValueS390X_OpSqrt(v) + return rewriteValueS390X_OpSqrt_0(v) case OpStaticCall: - return rewriteValueS390X_OpStaticCall(v) + return rewriteValueS390X_OpStaticCall_0(v) case OpStore: - return rewriteValueS390X_OpStore(v) + return rewriteValueS390X_OpStore_0(v) case OpSub16: - return rewriteValueS390X_OpSub16(v) + return rewriteValueS390X_OpSub16_0(v) case OpSub32: - return rewriteValueS390X_OpSub32(v) + return rewriteValueS390X_OpSub32_0(v) case OpSub32F: - return rewriteValueS390X_OpSub32F(v) + return rewriteValueS390X_OpSub32F_0(v) case OpSub64: - return rewriteValueS390X_OpSub64(v) + return rewriteValueS390X_OpSub64_0(v) case OpSub64F: - return rewriteValueS390X_OpSub64F(v) + return rewriteValueS390X_OpSub64F_0(v) case OpSub8: - return rewriteValueS390X_OpSub8(v) + return rewriteValueS390X_OpSub8_0(v) case OpSubPtr: - return rewriteValueS390X_OpSubPtr(v) + return rewriteValueS390X_OpSubPtr_0(v) case OpTrunc16to8: - return rewriteValueS390X_OpTrunc16to8(v) + return rewriteValueS390X_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValueS390X_OpTrunc32to16(v) + return rewriteValueS390X_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValueS390X_OpTrunc32to8(v) + return rewriteValueS390X_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValueS390X_OpTrunc64to16(v) + return rewriteValueS390X_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValueS390X_OpTrunc64to32(v) + return rewriteValueS390X_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValueS390X_OpTrunc64to8(v) + return rewriteValueS390X_OpTrunc64to8_0(v) case OpXor16: - return rewriteValueS390X_OpXor16(v) + return rewriteValueS390X_OpXor16_0(v) case OpXor32: - return rewriteValueS390X_OpXor32(v) + return rewriteValueS390X_OpXor32_0(v) case OpXor64: - return rewriteValueS390X_OpXor64(v) + return rewriteValueS390X_OpXor64_0(v) case OpXor8: - return rewriteValueS390X_OpXor8(v) + return rewriteValueS390X_OpXor8_0(v) case OpZero: - return rewriteValueS390X_OpZero(v) + return rewriteValueS390X_OpZero_0(v) || rewriteValueS390X_OpZero_10(v) case OpZeroExt16to32: - return rewriteValueS390X_OpZeroExt16to32(v) + return rewriteValueS390X_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValueS390X_OpZeroExt16to64(v) + return rewriteValueS390X_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValueS390X_OpZeroExt32to64(v) + return rewriteValueS390X_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValueS390X_OpZeroExt8to16(v) + return rewriteValueS390X_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValueS390X_OpZeroExt8to32(v) + return rewriteValueS390X_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValueS390X_OpZeroExt8to64(v) + return rewriteValueS390X_OpZeroExt8to64_0(v) } return false } -func rewriteValueS390X_OpAdd16(v *Value) bool { +func rewriteValueS390X_OpAdd16_0(v *Value) bool { // match: (Add16 x y) // cond: // result: (ADDW x y) @@ -733,7 +733,7 @@ func rewriteValueS390X_OpAdd16(v *Value) bool { return true } } -func rewriteValueS390X_OpAdd32(v *Value) bool { +func rewriteValueS390X_OpAdd32_0(v *Value) bool { // match: (Add32 x y) // cond: // result: (ADDW x y) @@ -746,7 +746,7 @@ func rewriteValueS390X_OpAdd32(v *Value) bool { return true } } -func rewriteValueS390X_OpAdd32F(v *Value) bool { +func rewriteValueS390X_OpAdd32F_0(v *Value) bool { // match: (Add32F x y) // cond: // result: (FADDS x y) @@ -759,7 +759,7 @@ func rewriteValueS390X_OpAdd32F(v *Value) bool { return true } } -func rewriteValueS390X_OpAdd64(v *Value) bool { +func rewriteValueS390X_OpAdd64_0(v *Value) bool { // match: (Add64 x y) // cond: // result: (ADD x y) @@ -772,7 +772,7 @@ func rewriteValueS390X_OpAdd64(v *Value) bool { return true } } -func rewriteValueS390X_OpAdd64F(v *Value) bool { +func rewriteValueS390X_OpAdd64F_0(v *Value) bool { // match: (Add64F x y) // cond: // result: (FADD x y) @@ -785,7 +785,7 @@ func rewriteValueS390X_OpAdd64F(v *Value) bool { return true } } -func rewriteValueS390X_OpAdd8(v *Value) bool { +func rewriteValueS390X_OpAdd8_0(v *Value) bool { // match: (Add8 x y) // cond: // result: (ADDW x y) @@ -798,7 +798,7 @@ func rewriteValueS390X_OpAdd8(v *Value) bool { return true } } -func rewriteValueS390X_OpAddPtr(v *Value) bool { +func rewriteValueS390X_OpAddPtr_0(v *Value) bool { // match: (AddPtr x y) // cond: // result: (ADD x y) @@ -811,7 +811,7 @@ func rewriteValueS390X_OpAddPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpAddr(v *Value) bool { +func rewriteValueS390X_OpAddr_0(v *Value) bool { // match: (Addr {sym} base) // cond: // result: (MOVDaddr {sym} base) @@ -824,7 +824,7 @@ func rewriteValueS390X_OpAddr(v *Value) bool { return true } } -func rewriteValueS390X_OpAnd16(v *Value) bool { +func rewriteValueS390X_OpAnd16_0(v *Value) bool { // match: (And16 x y) // cond: // result: (ANDW x y) @@ -837,7 +837,7 @@ func rewriteValueS390X_OpAnd16(v *Value) bool { return true } } -func rewriteValueS390X_OpAnd32(v *Value) bool { +func rewriteValueS390X_OpAnd32_0(v *Value) bool { // match: (And32 x y) // cond: // result: (ANDW x y) @@ -850,7 +850,7 @@ func rewriteValueS390X_OpAnd32(v *Value) bool { return true } } -func rewriteValueS390X_OpAnd64(v *Value) bool { +func rewriteValueS390X_OpAnd64_0(v *Value) bool { // match: (And64 x y) // cond: // result: (AND x y) @@ -863,7 +863,7 @@ func rewriteValueS390X_OpAnd64(v *Value) bool { return true } } -func rewriteValueS390X_OpAnd8(v *Value) bool { +func rewriteValueS390X_OpAnd8_0(v *Value) bool { // match: (And8 x y) // cond: // result: (ANDW x y) @@ -876,7 +876,7 @@ func rewriteValueS390X_OpAnd8(v *Value) bool { return true } } -func rewriteValueS390X_OpAndB(v *Value) bool { +func rewriteValueS390X_OpAndB_0(v *Value) bool { // match: (AndB x y) // cond: // result: (ANDW x y) @@ -889,7 +889,7 @@ func rewriteValueS390X_OpAndB(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicAdd32(v *Value) bool { +func rewriteValueS390X_OpAtomicAdd32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -911,7 +911,7 @@ func rewriteValueS390X_OpAtomicAdd32(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicAdd64(v *Value) bool { +func rewriteValueS390X_OpAtomicAdd64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -933,7 +933,7 @@ func rewriteValueS390X_OpAtomicAdd64(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool { +func rewriteValueS390X_OpAtomicCompareAndSwap32_0(v *Value) bool { // match: (AtomicCompareAndSwap32 ptr old new_ mem) // cond: // result: (LoweredAtomicCas32 ptr old new_ mem) @@ -950,7 +950,7 @@ func rewriteValueS390X_OpAtomicCompareAndSwap32(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool { +func rewriteValueS390X_OpAtomicCompareAndSwap64_0(v *Value) bool { // match: (AtomicCompareAndSwap64 ptr old new_ mem) // cond: // result: (LoweredAtomicCas64 ptr old new_ mem) @@ -967,7 +967,7 @@ func rewriteValueS390X_OpAtomicCompareAndSwap64(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicExchange32(v *Value) bool { +func rewriteValueS390X_OpAtomicExchange32_0(v *Value) bool { // match: (AtomicExchange32 ptr val mem) // cond: // result: (LoweredAtomicExchange32 ptr val mem) @@ -982,7 +982,7 @@ func rewriteValueS390X_OpAtomicExchange32(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicExchange64(v *Value) bool { +func rewriteValueS390X_OpAtomicExchange64_0(v *Value) bool { // match: (AtomicExchange64 ptr val mem) // cond: // result: (LoweredAtomicExchange64 ptr val mem) @@ -997,7 +997,7 @@ func rewriteValueS390X_OpAtomicExchange64(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicLoad32(v *Value) bool { +func rewriteValueS390X_OpAtomicLoad32_0(v *Value) bool { // match: (AtomicLoad32 ptr mem) // cond: // result: (MOVWZatomicload ptr mem) @@ -1010,7 +1010,7 @@ func rewriteValueS390X_OpAtomicLoad32(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicLoad64(v *Value) bool { +func rewriteValueS390X_OpAtomicLoad64_0(v *Value) bool { // match: (AtomicLoad64 ptr mem) // cond: // result: (MOVDatomicload ptr mem) @@ -1023,7 +1023,7 @@ func rewriteValueS390X_OpAtomicLoad64(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool { +func rewriteValueS390X_OpAtomicLoadPtr_0(v *Value) bool { // match: (AtomicLoadPtr ptr mem) // cond: // result: (MOVDatomicload ptr mem) @@ -1036,7 +1036,7 @@ func rewriteValueS390X_OpAtomicLoadPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicStore32(v *Value) bool { +func rewriteValueS390X_OpAtomicStore32_0(v *Value) bool { // match: (AtomicStore32 ptr val mem) // cond: // result: (MOVWatomicstore ptr val mem) @@ -1051,7 +1051,7 @@ func rewriteValueS390X_OpAtomicStore32(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicStore64(v *Value) bool { +func rewriteValueS390X_OpAtomicStore64_0(v *Value) bool { // match: (AtomicStore64 ptr val mem) // cond: // result: (MOVDatomicstore ptr val mem) @@ -1066,7 +1066,7 @@ func rewriteValueS390X_OpAtomicStore64(v *Value) bool { return true } } -func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool { +func rewriteValueS390X_OpAtomicStorePtrNoWB_0(v *Value) bool { // match: (AtomicStorePtrNoWB ptr val mem) // cond: // result: (MOVDatomicstore ptr val mem) @@ -1081,7 +1081,7 @@ func rewriteValueS390X_OpAtomicStorePtrNoWB(v *Value) bool { return true } } -func rewriteValueS390X_OpAvg64u(v *Value) bool { +func rewriteValueS390X_OpAvg64u_0(v *Value) bool { b := v.Block _ = b // match: (Avg64u x y) @@ -1103,7 +1103,7 @@ func rewriteValueS390X_OpAvg64u(v *Value) bool { return true } } -func rewriteValueS390X_OpBitLen64(v *Value) bool { +func rewriteValueS390X_OpBitLen64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1123,7 +1123,7 @@ func rewriteValueS390X_OpBitLen64(v *Value) bool { return true } } -func rewriteValueS390X_OpBswap32(v *Value) bool { +func rewriteValueS390X_OpBswap32_0(v *Value) bool { // match: (Bswap32 x) // cond: // result: (MOVWBR x) @@ -1134,7 +1134,7 @@ func rewriteValueS390X_OpBswap32(v *Value) bool { return true } } -func rewriteValueS390X_OpBswap64(v *Value) bool { +func rewriteValueS390X_OpBswap64_0(v *Value) bool { // match: (Bswap64 x) // cond: // result: (MOVDBR x) @@ -1145,7 +1145,7 @@ func rewriteValueS390X_OpBswap64(v *Value) bool { return true } } -func rewriteValueS390X_OpClosureCall(v *Value) bool { +func rewriteValueS390X_OpClosureCall_0(v *Value) bool { // match: (ClosureCall [argwid] entry closure mem) // cond: // result: (CALLclosure [argwid] entry closure mem) @@ -1162,7 +1162,7 @@ func rewriteValueS390X_OpClosureCall(v *Value) bool { return true } } -func rewriteValueS390X_OpCom16(v *Value) bool { +func rewriteValueS390X_OpCom16_0(v *Value) bool { // match: (Com16 x) // cond: // result: (NOTW x) @@ -1173,7 +1173,7 @@ func rewriteValueS390X_OpCom16(v *Value) bool { return true } } -func rewriteValueS390X_OpCom32(v *Value) bool { +func rewriteValueS390X_OpCom32_0(v *Value) bool { // match: (Com32 x) // cond: // result: (NOTW x) @@ -1184,7 +1184,7 @@ func rewriteValueS390X_OpCom32(v *Value) bool { return true } } -func rewriteValueS390X_OpCom64(v *Value) bool { +func rewriteValueS390X_OpCom64_0(v *Value) bool { // match: (Com64 x) // cond: // result: (NOT x) @@ -1195,7 +1195,7 @@ func rewriteValueS390X_OpCom64(v *Value) bool { return true } } -func rewriteValueS390X_OpCom8(v *Value) bool { +func rewriteValueS390X_OpCom8_0(v *Value) bool { // match: (Com8 x) // cond: // result: (NOTW x) @@ -1206,7 +1206,7 @@ func rewriteValueS390X_OpCom8(v *Value) bool { return true } } -func rewriteValueS390X_OpConst16(v *Value) bool { +func rewriteValueS390X_OpConst16_0(v *Value) bool { // match: (Const16 [val]) // cond: // result: (MOVDconst [val]) @@ -1217,7 +1217,7 @@ func rewriteValueS390X_OpConst16(v *Value) bool { return true } } -func rewriteValueS390X_OpConst32(v *Value) bool { +func rewriteValueS390X_OpConst32_0(v *Value) bool { // match: (Const32 [val]) // cond: // result: (MOVDconst [val]) @@ -1228,7 +1228,7 @@ func rewriteValueS390X_OpConst32(v *Value) bool { return true } } -func rewriteValueS390X_OpConst32F(v *Value) bool { +func rewriteValueS390X_OpConst32F_0(v *Value) bool { // match: (Const32F [val]) // cond: // result: (FMOVSconst [val]) @@ -1239,7 +1239,7 @@ func rewriteValueS390X_OpConst32F(v *Value) bool { return true } } -func rewriteValueS390X_OpConst64(v *Value) bool { +func rewriteValueS390X_OpConst64_0(v *Value) bool { // match: (Const64 [val]) // cond: // result: (MOVDconst [val]) @@ -1250,7 +1250,7 @@ func rewriteValueS390X_OpConst64(v *Value) bool { return true } } -func rewriteValueS390X_OpConst64F(v *Value) bool { +func rewriteValueS390X_OpConst64F_0(v *Value) bool { // match: (Const64F [val]) // cond: // result: (FMOVDconst [val]) @@ -1261,7 +1261,7 @@ func rewriteValueS390X_OpConst64F(v *Value) bool { return true } } -func rewriteValueS390X_OpConst8(v *Value) bool { +func rewriteValueS390X_OpConst8_0(v *Value) bool { // match: (Const8 [val]) // cond: // result: (MOVDconst [val]) @@ -1272,7 +1272,7 @@ func rewriteValueS390X_OpConst8(v *Value) bool { return true } } -func rewriteValueS390X_OpConstBool(v *Value) bool { +func rewriteValueS390X_OpConstBool_0(v *Value) bool { // match: (ConstBool [b]) // cond: // result: (MOVDconst [b]) @@ -1283,7 +1283,7 @@ func rewriteValueS390X_OpConstBool(v *Value) bool { return true } } -func rewriteValueS390X_OpConstNil(v *Value) bool { +func rewriteValueS390X_OpConstNil_0(v *Value) bool { // match: (ConstNil) // cond: // result: (MOVDconst [0]) @@ -1293,7 +1293,7 @@ func rewriteValueS390X_OpConstNil(v *Value) bool { return true } } -func rewriteValueS390X_OpConvert(v *Value) bool { +func rewriteValueS390X_OpConvert_0(v *Value) bool { // match: (Convert x mem) // cond: // result: (MOVDconvert x mem) @@ -1308,7 +1308,7 @@ func rewriteValueS390X_OpConvert(v *Value) bool { return true } } -func rewriteValueS390X_OpCtz32(v *Value) bool { +func rewriteValueS390X_OpCtz32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1339,7 +1339,7 @@ func rewriteValueS390X_OpCtz32(v *Value) bool { return true } } -func rewriteValueS390X_OpCtz64(v *Value) bool { +func rewriteValueS390X_OpCtz64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1368,7 +1368,7 @@ func rewriteValueS390X_OpCtz64(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt32Fto32(v *Value) bool { +func rewriteValueS390X_OpCvt32Fto32_0(v *Value) bool { // match: (Cvt32Fto32 x) // cond: // result: (CFEBRA x) @@ -1379,7 +1379,7 @@ func rewriteValueS390X_OpCvt32Fto32(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt32Fto64(v *Value) bool { +func rewriteValueS390X_OpCvt32Fto64_0(v *Value) bool { // match: (Cvt32Fto64 x) // cond: // result: (CGEBRA x) @@ -1390,7 +1390,7 @@ func rewriteValueS390X_OpCvt32Fto64(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool { +func rewriteValueS390X_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F x) // cond: // result: (LDEBR x) @@ -1401,7 +1401,7 @@ func rewriteValueS390X_OpCvt32Fto64F(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt32to32F(v *Value) bool { +func rewriteValueS390X_OpCvt32to32F_0(v *Value) bool { // match: (Cvt32to32F x) // cond: // result: (CEFBRA x) @@ -1412,7 +1412,7 @@ func rewriteValueS390X_OpCvt32to32F(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt32to64F(v *Value) bool { +func rewriteValueS390X_OpCvt32to64F_0(v *Value) bool { // match: (Cvt32to64F x) // cond: // result: (CDFBRA x) @@ -1423,7 +1423,7 @@ func rewriteValueS390X_OpCvt32to64F(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt64Fto32(v *Value) bool { +func rewriteValueS390X_OpCvt64Fto32_0(v *Value) bool { // match: (Cvt64Fto32 x) // cond: // result: (CFDBRA x) @@ -1434,7 +1434,7 @@ func rewriteValueS390X_OpCvt64Fto32(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool { +func rewriteValueS390X_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F x) // cond: // result: (LEDBR x) @@ -1445,7 +1445,7 @@ func rewriteValueS390X_OpCvt64Fto32F(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt64Fto64(v *Value) bool { +func rewriteValueS390X_OpCvt64Fto64_0(v *Value) bool { // match: (Cvt64Fto64 x) // cond: // result: (CGDBRA x) @@ -1456,7 +1456,7 @@ func rewriteValueS390X_OpCvt64Fto64(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt64to32F(v *Value) bool { +func rewriteValueS390X_OpCvt64to32F_0(v *Value) bool { // match: (Cvt64to32F x) // cond: // result: (CEGBRA x) @@ -1467,7 +1467,7 @@ func rewriteValueS390X_OpCvt64to32F(v *Value) bool { return true } } -func rewriteValueS390X_OpCvt64to64F(v *Value) bool { +func rewriteValueS390X_OpCvt64to64F_0(v *Value) bool { // match: (Cvt64to64F x) // cond: // result: (CDGBRA x) @@ -1478,7 +1478,7 @@ func rewriteValueS390X_OpCvt64to64F(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv16(v *Value) bool { +func rewriteValueS390X_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1499,7 +1499,7 @@ func rewriteValueS390X_OpDiv16(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv16u(v *Value) bool { +func rewriteValueS390X_OpDiv16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1520,7 +1520,7 @@ func rewriteValueS390X_OpDiv16u(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv32(v *Value) bool { +func rewriteValueS390X_OpDiv32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1539,7 +1539,7 @@ func rewriteValueS390X_OpDiv32(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv32F(v *Value) bool { +func rewriteValueS390X_OpDiv32F_0(v *Value) bool { // match: (Div32F x y) // cond: // result: (FDIVS x y) @@ -1552,7 +1552,7 @@ func rewriteValueS390X_OpDiv32F(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv32u(v *Value) bool { +func rewriteValueS390X_OpDiv32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1571,7 +1571,7 @@ func rewriteValueS390X_OpDiv32u(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv64(v *Value) bool { +func rewriteValueS390X_OpDiv64_0(v *Value) bool { // match: (Div64 x y) // cond: // result: (DIVD x y) @@ -1584,7 +1584,7 @@ func rewriteValueS390X_OpDiv64(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv64F(v *Value) bool { +func rewriteValueS390X_OpDiv64F_0(v *Value) bool { // match: (Div64F x y) // cond: // result: (FDIV x y) @@ -1597,7 +1597,7 @@ func rewriteValueS390X_OpDiv64F(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv64u(v *Value) bool { +func rewriteValueS390X_OpDiv64u_0(v *Value) bool { // match: (Div64u x y) // cond: // result: (DIVDU x y) @@ -1610,7 +1610,7 @@ func rewriteValueS390X_OpDiv64u(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv8(v *Value) bool { +func rewriteValueS390X_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1631,7 +1631,7 @@ func rewriteValueS390X_OpDiv8(v *Value) bool { return true } } -func rewriteValueS390X_OpDiv8u(v *Value) bool { +func rewriteValueS390X_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1652,7 +1652,7 @@ func rewriteValueS390X_OpDiv8u(v *Value) bool { return true } } -func rewriteValueS390X_OpEq16(v *Value) bool { +func rewriteValueS390X_OpEq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1681,7 +1681,7 @@ func rewriteValueS390X_OpEq16(v *Value) bool { return true } } -func rewriteValueS390X_OpEq32(v *Value) bool { +func rewriteValueS390X_OpEq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1706,7 +1706,7 @@ func rewriteValueS390X_OpEq32(v *Value) bool { return true } } -func rewriteValueS390X_OpEq32F(v *Value) bool { +func rewriteValueS390X_OpEq32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1731,7 +1731,7 @@ func rewriteValueS390X_OpEq32F(v *Value) bool { return true } } -func rewriteValueS390X_OpEq64(v *Value) bool { +func rewriteValueS390X_OpEq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1756,7 +1756,7 @@ func rewriteValueS390X_OpEq64(v *Value) bool { return true } } -func rewriteValueS390X_OpEq64F(v *Value) bool { +func rewriteValueS390X_OpEq64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1781,7 +1781,7 @@ func rewriteValueS390X_OpEq64F(v *Value) bool { return true } } -func rewriteValueS390X_OpEq8(v *Value) bool { +func rewriteValueS390X_OpEq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1810,7 +1810,7 @@ func rewriteValueS390X_OpEq8(v *Value) bool { return true } } -func rewriteValueS390X_OpEqB(v *Value) bool { +func rewriteValueS390X_OpEqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1839,7 +1839,7 @@ func rewriteValueS390X_OpEqB(v *Value) bool { return true } } -func rewriteValueS390X_OpEqPtr(v *Value) bool { +func rewriteValueS390X_OpEqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1864,7 +1864,7 @@ func rewriteValueS390X_OpEqPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq16(v *Value) bool { +func rewriteValueS390X_OpGeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1893,7 +1893,7 @@ func rewriteValueS390X_OpGeq16(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq16U(v *Value) bool { +func rewriteValueS390X_OpGeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1922,7 +1922,7 @@ func rewriteValueS390X_OpGeq16U(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq32(v *Value) bool { +func rewriteValueS390X_OpGeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1947,7 +1947,7 @@ func rewriteValueS390X_OpGeq32(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq32F(v *Value) bool { +func rewriteValueS390X_OpGeq32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1972,7 +1972,7 @@ func rewriteValueS390X_OpGeq32F(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq32U(v *Value) bool { +func rewriteValueS390X_OpGeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1997,7 +1997,7 @@ func rewriteValueS390X_OpGeq32U(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq64(v *Value) bool { +func rewriteValueS390X_OpGeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2022,7 +2022,7 @@ func rewriteValueS390X_OpGeq64(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq64F(v *Value) bool { +func rewriteValueS390X_OpGeq64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2047,7 +2047,7 @@ func rewriteValueS390X_OpGeq64F(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq64U(v *Value) bool { +func rewriteValueS390X_OpGeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2072,7 +2072,7 @@ func rewriteValueS390X_OpGeq64U(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq8(v *Value) bool { +func rewriteValueS390X_OpGeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2101,7 +2101,7 @@ func rewriteValueS390X_OpGeq8(v *Value) bool { return true } } -func rewriteValueS390X_OpGeq8U(v *Value) bool { +func rewriteValueS390X_OpGeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2130,7 +2130,7 @@ func rewriteValueS390X_OpGeq8U(v *Value) bool { return true } } -func rewriteValueS390X_OpGetClosurePtr(v *Value) bool { +func rewriteValueS390X_OpGetClosurePtr_0(v *Value) bool { // match: (GetClosurePtr) // cond: // result: (LoweredGetClosurePtr) @@ -2139,7 +2139,7 @@ func rewriteValueS390X_OpGetClosurePtr(v *Value) bool { return true } } -func rewriteValueS390X_OpGetG(v *Value) bool { +func rewriteValueS390X_OpGetG_0(v *Value) bool { // match: (GetG mem) // cond: // result: (LoweredGetG mem) @@ -2150,7 +2150,7 @@ func rewriteValueS390X_OpGetG(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater16(v *Value) bool { +func rewriteValueS390X_OpGreater16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2179,7 +2179,7 @@ func rewriteValueS390X_OpGreater16(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater16U(v *Value) bool { +func rewriteValueS390X_OpGreater16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2208,7 +2208,7 @@ func rewriteValueS390X_OpGreater16U(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater32(v *Value) bool { +func rewriteValueS390X_OpGreater32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2233,7 +2233,7 @@ func rewriteValueS390X_OpGreater32(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater32F(v *Value) bool { +func rewriteValueS390X_OpGreater32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2258,7 +2258,7 @@ func rewriteValueS390X_OpGreater32F(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater32U(v *Value) bool { +func rewriteValueS390X_OpGreater32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2283,7 +2283,7 @@ func rewriteValueS390X_OpGreater32U(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater64(v *Value) bool { +func rewriteValueS390X_OpGreater64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2308,7 +2308,7 @@ func rewriteValueS390X_OpGreater64(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater64F(v *Value) bool { +func rewriteValueS390X_OpGreater64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2333,7 +2333,7 @@ func rewriteValueS390X_OpGreater64F(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater64U(v *Value) bool { +func rewriteValueS390X_OpGreater64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2358,7 +2358,7 @@ func rewriteValueS390X_OpGreater64U(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater8(v *Value) bool { +func rewriteValueS390X_OpGreater8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2387,7 +2387,7 @@ func rewriteValueS390X_OpGreater8(v *Value) bool { return true } } -func rewriteValueS390X_OpGreater8U(v *Value) bool { +func rewriteValueS390X_OpGreater8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2416,7 +2416,7 @@ func rewriteValueS390X_OpGreater8U(v *Value) bool { return true } } -func rewriteValueS390X_OpHmul32(v *Value) bool { +func rewriteValueS390X_OpHmul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2440,7 +2440,7 @@ func rewriteValueS390X_OpHmul32(v *Value) bool { return true } } -func rewriteValueS390X_OpHmul32u(v *Value) bool { +func rewriteValueS390X_OpHmul32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2464,7 +2464,7 @@ func rewriteValueS390X_OpHmul32u(v *Value) bool { return true } } -func rewriteValueS390X_OpHmul64(v *Value) bool { +func rewriteValueS390X_OpHmul64_0(v *Value) bool { // match: (Hmul64 x y) // cond: // result: (MULHD x y) @@ -2477,7 +2477,7 @@ func rewriteValueS390X_OpHmul64(v *Value) bool { return true } } -func rewriteValueS390X_OpHmul64u(v *Value) bool { +func rewriteValueS390X_OpHmul64u_0(v *Value) bool { // match: (Hmul64u x y) // cond: // result: (MULHDU x y) @@ -2490,7 +2490,7 @@ func rewriteValueS390X_OpHmul64u(v *Value) bool { return true } } -func rewriteValueS390X_OpITab(v *Value) bool { +func rewriteValueS390X_OpITab_0(v *Value) bool { // match: (ITab (Load ptr mem)) // cond: // result: (MOVDload ptr mem) @@ -2508,7 +2508,7 @@ func rewriteValueS390X_OpITab(v *Value) bool { } return false } -func rewriteValueS390X_OpInterCall(v *Value) bool { +func rewriteValueS390X_OpInterCall_0(v *Value) bool { // match: (InterCall [argwid] entry mem) // cond: // result: (CALLinter [argwid] entry mem) @@ -2523,7 +2523,7 @@ func rewriteValueS390X_OpInterCall(v *Value) bool { return true } } -func rewriteValueS390X_OpIsInBounds(v *Value) bool { +func rewriteValueS390X_OpIsInBounds_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2548,7 +2548,7 @@ func rewriteValueS390X_OpIsInBounds(v *Value) bool { return true } } -func rewriteValueS390X_OpIsNonNil(v *Value) bool { +func rewriteValueS390X_OpIsNonNil_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2572,7 +2572,7 @@ func rewriteValueS390X_OpIsNonNil(v *Value) bool { return true } } -func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool { +func rewriteValueS390X_OpIsSliceInBounds_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2597,7 +2597,7 @@ func rewriteValueS390X_OpIsSliceInBounds(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq16(v *Value) bool { +func rewriteValueS390X_OpLeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2626,7 +2626,7 @@ func rewriteValueS390X_OpLeq16(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq16U(v *Value) bool { +func rewriteValueS390X_OpLeq16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2655,7 +2655,7 @@ func rewriteValueS390X_OpLeq16U(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq32(v *Value) bool { +func rewriteValueS390X_OpLeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2680,7 +2680,7 @@ func rewriteValueS390X_OpLeq32(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq32F(v *Value) bool { +func rewriteValueS390X_OpLeq32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2705,7 +2705,7 @@ func rewriteValueS390X_OpLeq32F(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq32U(v *Value) bool { +func rewriteValueS390X_OpLeq32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2730,7 +2730,7 @@ func rewriteValueS390X_OpLeq32U(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq64(v *Value) bool { +func rewriteValueS390X_OpLeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2755,7 +2755,7 @@ func rewriteValueS390X_OpLeq64(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq64F(v *Value) bool { +func rewriteValueS390X_OpLeq64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2780,7 +2780,7 @@ func rewriteValueS390X_OpLeq64F(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq64U(v *Value) bool { +func rewriteValueS390X_OpLeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2805,7 +2805,7 @@ func rewriteValueS390X_OpLeq64U(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq8(v *Value) bool { +func rewriteValueS390X_OpLeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2834,7 +2834,7 @@ func rewriteValueS390X_OpLeq8(v *Value) bool { return true } } -func rewriteValueS390X_OpLeq8U(v *Value) bool { +func rewriteValueS390X_OpLeq8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2863,7 +2863,7 @@ func rewriteValueS390X_OpLeq8U(v *Value) bool { return true } } -func rewriteValueS390X_OpLess16(v *Value) bool { +func rewriteValueS390X_OpLess16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2892,7 +2892,7 @@ func rewriteValueS390X_OpLess16(v *Value) bool { return true } } -func rewriteValueS390X_OpLess16U(v *Value) bool { +func rewriteValueS390X_OpLess16U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2921,7 +2921,7 @@ func rewriteValueS390X_OpLess16U(v *Value) bool { return true } } -func rewriteValueS390X_OpLess32(v *Value) bool { +func rewriteValueS390X_OpLess32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2946,7 +2946,7 @@ func rewriteValueS390X_OpLess32(v *Value) bool { return true } } -func rewriteValueS390X_OpLess32F(v *Value) bool { +func rewriteValueS390X_OpLess32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2971,7 +2971,7 @@ func rewriteValueS390X_OpLess32F(v *Value) bool { return true } } -func rewriteValueS390X_OpLess32U(v *Value) bool { +func rewriteValueS390X_OpLess32U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2996,7 +2996,7 @@ func rewriteValueS390X_OpLess32U(v *Value) bool { return true } } -func rewriteValueS390X_OpLess64(v *Value) bool { +func rewriteValueS390X_OpLess64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3021,7 +3021,7 @@ func rewriteValueS390X_OpLess64(v *Value) bool { return true } } -func rewriteValueS390X_OpLess64F(v *Value) bool { +func rewriteValueS390X_OpLess64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3046,7 +3046,7 @@ func rewriteValueS390X_OpLess64F(v *Value) bool { return true } } -func rewriteValueS390X_OpLess64U(v *Value) bool { +func rewriteValueS390X_OpLess64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3071,7 +3071,7 @@ func rewriteValueS390X_OpLess64U(v *Value) bool { return true } } -func rewriteValueS390X_OpLess8(v *Value) bool { +func rewriteValueS390X_OpLess8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3100,7 +3100,7 @@ func rewriteValueS390X_OpLess8(v *Value) bool { return true } } -func rewriteValueS390X_OpLess8U(v *Value) bool { +func rewriteValueS390X_OpLess8U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3129,7 +3129,7 @@ func rewriteValueS390X_OpLess8U(v *Value) bool { return true } } -func rewriteValueS390X_OpLoad(v *Value) bool { +func rewriteValueS390X_OpLoad_0(v *Value) bool { // match: (Load ptr mem) // cond: (is64BitInt(t) || isPtr(t)) // result: (MOVDload ptr mem) @@ -3267,7 +3267,7 @@ func rewriteValueS390X_OpLoad(v *Value) bool { } return false } -func rewriteValueS390X_OpLsh16x16(v *Value) bool { +func rewriteValueS390X_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3295,7 +3295,7 @@ func rewriteValueS390X_OpLsh16x16(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh16x32(v *Value) bool { +func rewriteValueS390X_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x y) @@ -3319,7 +3319,7 @@ func rewriteValueS390X_OpLsh16x32(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh16x64(v *Value) bool { +func rewriteValueS390X_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x64 x y) @@ -3343,7 +3343,7 @@ func rewriteValueS390X_OpLsh16x64(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh16x8(v *Value) bool { +func rewriteValueS390X_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3371,7 +3371,7 @@ func rewriteValueS390X_OpLsh16x8(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh32x16(v *Value) bool { +func rewriteValueS390X_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3399,7 +3399,7 @@ func rewriteValueS390X_OpLsh32x16(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh32x32(v *Value) bool { +func rewriteValueS390X_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x y) @@ -3423,7 +3423,7 @@ func rewriteValueS390X_OpLsh32x32(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh32x64(v *Value) bool { +func rewriteValueS390X_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x64 x y) @@ -3447,7 +3447,7 @@ func rewriteValueS390X_OpLsh32x64(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh32x8(v *Value) bool { +func rewriteValueS390X_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3475,7 +3475,7 @@ func rewriteValueS390X_OpLsh32x8(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh64x16(v *Value) bool { +func rewriteValueS390X_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3503,7 +3503,7 @@ func rewriteValueS390X_OpLsh64x16(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh64x32(v *Value) bool { +func rewriteValueS390X_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 x y) @@ -3527,7 +3527,7 @@ func rewriteValueS390X_OpLsh64x32(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh64x64(v *Value) bool { +func rewriteValueS390X_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x64 x y) @@ -3551,7 +3551,7 @@ func rewriteValueS390X_OpLsh64x64(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh64x8(v *Value) bool { +func rewriteValueS390X_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3579,7 +3579,7 @@ func rewriteValueS390X_OpLsh64x8(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh8x16(v *Value) bool { +func rewriteValueS390X_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3607,7 +3607,7 @@ func rewriteValueS390X_OpLsh8x16(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh8x32(v *Value) bool { +func rewriteValueS390X_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x y) @@ -3631,7 +3631,7 @@ func rewriteValueS390X_OpLsh8x32(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh8x64(v *Value) bool { +func rewriteValueS390X_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x64 x y) @@ -3655,7 +3655,7 @@ func rewriteValueS390X_OpLsh8x64(v *Value) bool { return true } } -func rewriteValueS390X_OpLsh8x8(v *Value) bool { +func rewriteValueS390X_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3683,7 +3683,7 @@ func rewriteValueS390X_OpLsh8x8(v *Value) bool { return true } } -func rewriteValueS390X_OpMod16(v *Value) bool { +func rewriteValueS390X_OpMod16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3704,7 +3704,7 @@ func rewriteValueS390X_OpMod16(v *Value) bool { return true } } -func rewriteValueS390X_OpMod16u(v *Value) bool { +func rewriteValueS390X_OpMod16u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3725,7 +3725,7 @@ func rewriteValueS390X_OpMod16u(v *Value) bool { return true } } -func rewriteValueS390X_OpMod32(v *Value) bool { +func rewriteValueS390X_OpMod32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3744,7 +3744,7 @@ func rewriteValueS390X_OpMod32(v *Value) bool { return true } } -func rewriteValueS390X_OpMod32u(v *Value) bool { +func rewriteValueS390X_OpMod32u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3763,7 +3763,7 @@ func rewriteValueS390X_OpMod32u(v *Value) bool { return true } } -func rewriteValueS390X_OpMod64(v *Value) bool { +func rewriteValueS390X_OpMod64_0(v *Value) bool { // match: (Mod64 x y) // cond: // result: (MODD x y) @@ -3776,7 +3776,7 @@ func rewriteValueS390X_OpMod64(v *Value) bool { return true } } -func rewriteValueS390X_OpMod64u(v *Value) bool { +func rewriteValueS390X_OpMod64u_0(v *Value) bool { // match: (Mod64u x y) // cond: // result: (MODDU x y) @@ -3789,7 +3789,7 @@ func rewriteValueS390X_OpMod64u(v *Value) bool { return true } } -func rewriteValueS390X_OpMod8(v *Value) bool { +func rewriteValueS390X_OpMod8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3810,7 +3810,7 @@ func rewriteValueS390X_OpMod8(v *Value) bool { return true } } -func rewriteValueS390X_OpMod8u(v *Value) bool { +func rewriteValueS390X_OpMod8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -3831,7 +3831,7 @@ func rewriteValueS390X_OpMod8u(v *Value) bool { return true } } -func rewriteValueS390X_OpMove(v *Value) bool { +func rewriteValueS390X_OpMove_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4074,6 +4074,13 @@ func rewriteValueS390X_OpMove(v *Value) bool { v.AddArg(v1) return true } + return false +} +func rewriteValueS390X_OpMove_10(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (Move [7] dst src mem) // cond: // result: (MOVBstore [6] dst (MOVBZload [6] src mem) (MOVHstore [4] dst (MOVHZload [4] src mem) (MOVWstore dst (MOVWZload src mem) mem))) @@ -4237,7 +4244,7 @@ func rewriteValueS390X_OpMove(v *Value) bool { } return false } -func rewriteValueS390X_OpMul16(v *Value) bool { +func rewriteValueS390X_OpMul16_0(v *Value) bool { // match: (Mul16 x y) // cond: // result: (MULLW x y) @@ -4250,7 +4257,7 @@ func rewriteValueS390X_OpMul16(v *Value) bool { return true } } -func rewriteValueS390X_OpMul32(v *Value) bool { +func rewriteValueS390X_OpMul32_0(v *Value) bool { // match: (Mul32 x y) // cond: // result: (MULLW x y) @@ -4263,7 +4270,7 @@ func rewriteValueS390X_OpMul32(v *Value) bool { return true } } -func rewriteValueS390X_OpMul32F(v *Value) bool { +func rewriteValueS390X_OpMul32F_0(v *Value) bool { // match: (Mul32F x y) // cond: // result: (FMULS x y) @@ -4276,7 +4283,7 @@ func rewriteValueS390X_OpMul32F(v *Value) bool { return true } } -func rewriteValueS390X_OpMul64(v *Value) bool { +func rewriteValueS390X_OpMul64_0(v *Value) bool { // match: (Mul64 x y) // cond: // result: (MULLD x y) @@ -4289,7 +4296,7 @@ func rewriteValueS390X_OpMul64(v *Value) bool { return true } } -func rewriteValueS390X_OpMul64F(v *Value) bool { +func rewriteValueS390X_OpMul64F_0(v *Value) bool { // match: (Mul64F x y) // cond: // result: (FMUL x y) @@ -4302,7 +4309,7 @@ func rewriteValueS390X_OpMul64F(v *Value) bool { return true } } -func rewriteValueS390X_OpMul8(v *Value) bool { +func rewriteValueS390X_OpMul8_0(v *Value) bool { // match: (Mul8 x y) // cond: // result: (MULLW x y) @@ -4315,7 +4322,7 @@ func rewriteValueS390X_OpMul8(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg16(v *Value) bool { +func rewriteValueS390X_OpNeg16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4332,7 +4339,7 @@ func rewriteValueS390X_OpNeg16(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg32(v *Value) bool { +func rewriteValueS390X_OpNeg32_0(v *Value) bool { // match: (Neg32 x) // cond: // result: (NEGW x) @@ -4343,7 +4350,7 @@ func rewriteValueS390X_OpNeg32(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg32F(v *Value) bool { +func rewriteValueS390X_OpNeg32F_0(v *Value) bool { // match: (Neg32F x) // cond: // result: (FNEGS x) @@ -4354,7 +4361,7 @@ func rewriteValueS390X_OpNeg32F(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg64(v *Value) bool { +func rewriteValueS390X_OpNeg64_0(v *Value) bool { // match: (Neg64 x) // cond: // result: (NEG x) @@ -4365,7 +4372,7 @@ func rewriteValueS390X_OpNeg64(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg64F(v *Value) bool { +func rewriteValueS390X_OpNeg64F_0(v *Value) bool { // match: (Neg64F x) // cond: // result: (FNEG x) @@ -4376,7 +4383,7 @@ func rewriteValueS390X_OpNeg64F(v *Value) bool { return true } } -func rewriteValueS390X_OpNeg8(v *Value) bool { +func rewriteValueS390X_OpNeg8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4393,7 +4400,7 @@ func rewriteValueS390X_OpNeg8(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq16(v *Value) bool { +func rewriteValueS390X_OpNeq16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4422,7 +4429,7 @@ func rewriteValueS390X_OpNeq16(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq32(v *Value) bool { +func rewriteValueS390X_OpNeq32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4447,7 +4454,7 @@ func rewriteValueS390X_OpNeq32(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq32F(v *Value) bool { +func rewriteValueS390X_OpNeq32F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4472,7 +4479,7 @@ func rewriteValueS390X_OpNeq32F(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq64(v *Value) bool { +func rewriteValueS390X_OpNeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4497,7 +4504,7 @@ func rewriteValueS390X_OpNeq64(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq64F(v *Value) bool { +func rewriteValueS390X_OpNeq64F_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4522,7 +4529,7 @@ func rewriteValueS390X_OpNeq64F(v *Value) bool { return true } } -func rewriteValueS390X_OpNeq8(v *Value) bool { +func rewriteValueS390X_OpNeq8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4551,7 +4558,7 @@ func rewriteValueS390X_OpNeq8(v *Value) bool { return true } } -func rewriteValueS390X_OpNeqB(v *Value) bool { +func rewriteValueS390X_OpNeqB_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4580,7 +4587,7 @@ func rewriteValueS390X_OpNeqB(v *Value) bool { return true } } -func rewriteValueS390X_OpNeqPtr(v *Value) bool { +func rewriteValueS390X_OpNeqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4605,7 +4612,7 @@ func rewriteValueS390X_OpNeqPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpNilCheck(v *Value) bool { +func rewriteValueS390X_OpNilCheck_0(v *Value) bool { // match: (NilCheck ptr mem) // cond: // result: (LoweredNilCheck ptr mem) @@ -4618,7 +4625,7 @@ func rewriteValueS390X_OpNilCheck(v *Value) bool { return true } } -func rewriteValueS390X_OpNot(v *Value) bool { +func rewriteValueS390X_OpNot_0(v *Value) bool { // match: (Not x) // cond: // result: (XORWconst [1] x) @@ -4630,7 +4637,7 @@ func rewriteValueS390X_OpNot(v *Value) bool { return true } } -func rewriteValueS390X_OpOffPtr(v *Value) bool { +func rewriteValueS390X_OpOffPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4677,7 +4684,7 @@ func rewriteValueS390X_OpOffPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpOr16(v *Value) bool { +func rewriteValueS390X_OpOr16_0(v *Value) bool { // match: (Or16 x y) // cond: // result: (ORW x y) @@ -4690,7 +4697,7 @@ func rewriteValueS390X_OpOr16(v *Value) bool { return true } } -func rewriteValueS390X_OpOr32(v *Value) bool { +func rewriteValueS390X_OpOr32_0(v *Value) bool { // match: (Or32 x y) // cond: // result: (ORW x y) @@ -4703,7 +4710,7 @@ func rewriteValueS390X_OpOr32(v *Value) bool { return true } } -func rewriteValueS390X_OpOr64(v *Value) bool { +func rewriteValueS390X_OpOr64_0(v *Value) bool { // match: (Or64 x y) // cond: // result: (OR x y) @@ -4716,7 +4723,7 @@ func rewriteValueS390X_OpOr64(v *Value) bool { return true } } -func rewriteValueS390X_OpOr8(v *Value) bool { +func rewriteValueS390X_OpOr8_0(v *Value) bool { // match: (Or8 x y) // cond: // result: (ORW x y) @@ -4729,7 +4736,7 @@ func rewriteValueS390X_OpOr8(v *Value) bool { return true } } -func rewriteValueS390X_OpOrB(v *Value) bool { +func rewriteValueS390X_OpOrB_0(v *Value) bool { // match: (OrB x y) // cond: // result: (ORW x y) @@ -4742,7 +4749,7 @@ func rewriteValueS390X_OpOrB(v *Value) bool { return true } } -func rewriteValueS390X_OpRound32F(v *Value) bool { +func rewriteValueS390X_OpRound32F_0(v *Value) bool { // match: (Round32F x) // cond: // result: (LoweredRound32F x) @@ -4753,7 +4760,7 @@ func rewriteValueS390X_OpRound32F(v *Value) bool { return true } } -func rewriteValueS390X_OpRound64F(v *Value) bool { +func rewriteValueS390X_OpRound64F_0(v *Value) bool { // match: (Round64F x) // cond: // result: (LoweredRound64F x) @@ -4764,7 +4771,7 @@ func rewriteValueS390X_OpRound64F(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16Ux16(v *Value) bool { +func rewriteValueS390X_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4794,7 +4801,7 @@ func rewriteValueS390X_OpRsh16Ux16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16Ux32(v *Value) bool { +func rewriteValueS390X_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4822,7 +4829,7 @@ func rewriteValueS390X_OpRsh16Ux32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16Ux64(v *Value) bool { +func rewriteValueS390X_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4850,7 +4857,7 @@ func rewriteValueS390X_OpRsh16Ux64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16Ux8(v *Value) bool { +func rewriteValueS390X_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4880,7 +4887,7 @@ func rewriteValueS390X_OpRsh16Ux8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16x16(v *Value) bool { +func rewriteValueS390X_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4913,7 +4920,7 @@ func rewriteValueS390X_OpRsh16x16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16x32(v *Value) bool { +func rewriteValueS390X_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4944,7 +4951,7 @@ func rewriteValueS390X_OpRsh16x32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16x64(v *Value) bool { +func rewriteValueS390X_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -4975,7 +4982,7 @@ func rewriteValueS390X_OpRsh16x64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh16x8(v *Value) bool { +func rewriteValueS390X_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5008,7 +5015,7 @@ func rewriteValueS390X_OpRsh16x8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32Ux16(v *Value) bool { +func rewriteValueS390X_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5036,7 +5043,7 @@ func rewriteValueS390X_OpRsh32Ux16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32Ux32(v *Value) bool { +func rewriteValueS390X_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x y) @@ -5060,7 +5067,7 @@ func rewriteValueS390X_OpRsh32Ux32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32Ux64(v *Value) bool { +func rewriteValueS390X_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux64 x y) @@ -5084,7 +5091,7 @@ func rewriteValueS390X_OpRsh32Ux64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32Ux8(v *Value) bool { +func rewriteValueS390X_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5112,7 +5119,7 @@ func rewriteValueS390X_OpRsh32Ux8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32x16(v *Value) bool { +func rewriteValueS390X_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5143,7 +5150,7 @@ func rewriteValueS390X_OpRsh32x16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32x32(v *Value) bool { +func rewriteValueS390X_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x y) @@ -5170,7 +5177,7 @@ func rewriteValueS390X_OpRsh32x32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32x64(v *Value) bool { +func rewriteValueS390X_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x64 x y) @@ -5197,7 +5204,7 @@ func rewriteValueS390X_OpRsh32x64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh32x8(v *Value) bool { +func rewriteValueS390X_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5228,7 +5235,7 @@ func rewriteValueS390X_OpRsh32x8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64Ux16(v *Value) bool { +func rewriteValueS390X_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5256,7 +5263,7 @@ func rewriteValueS390X_OpRsh64Ux16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64Ux32(v *Value) bool { +func rewriteValueS390X_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 x y) @@ -5280,7 +5287,7 @@ func rewriteValueS390X_OpRsh64Ux32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64Ux64(v *Value) bool { +func rewriteValueS390X_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux64 x y) @@ -5304,7 +5311,7 @@ func rewriteValueS390X_OpRsh64Ux64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64Ux8(v *Value) bool { +func rewriteValueS390X_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5332,7 +5339,7 @@ func rewriteValueS390X_OpRsh64Ux8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64x16(v *Value) bool { +func rewriteValueS390X_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5363,7 +5370,7 @@ func rewriteValueS390X_OpRsh64x16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64x32(v *Value) bool { +func rewriteValueS390X_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 x y) @@ -5390,7 +5397,7 @@ func rewriteValueS390X_OpRsh64x32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64x64(v *Value) bool { +func rewriteValueS390X_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x64 x y) @@ -5417,7 +5424,7 @@ func rewriteValueS390X_OpRsh64x64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh64x8(v *Value) bool { +func rewriteValueS390X_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5448,7 +5455,7 @@ func rewriteValueS390X_OpRsh64x8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8Ux16(v *Value) bool { +func rewriteValueS390X_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5478,7 +5485,7 @@ func rewriteValueS390X_OpRsh8Ux16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8Ux32(v *Value) bool { +func rewriteValueS390X_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5506,7 +5513,7 @@ func rewriteValueS390X_OpRsh8Ux32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8Ux64(v *Value) bool { +func rewriteValueS390X_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5534,7 +5541,7 @@ func rewriteValueS390X_OpRsh8Ux64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8Ux8(v *Value) bool { +func rewriteValueS390X_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5564,7 +5571,7 @@ func rewriteValueS390X_OpRsh8Ux8(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8x16(v *Value) bool { +func rewriteValueS390X_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5597,7 +5604,7 @@ func rewriteValueS390X_OpRsh8x16(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8x32(v *Value) bool { +func rewriteValueS390X_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5628,7 +5635,7 @@ func rewriteValueS390X_OpRsh8x32(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8x64(v *Value) bool { +func rewriteValueS390X_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5659,7 +5666,7 @@ func rewriteValueS390X_OpRsh8x64(v *Value) bool { return true } } -func rewriteValueS390X_OpRsh8x8(v *Value) bool { +func rewriteValueS390X_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5692,7 +5699,7 @@ func rewriteValueS390X_OpRsh8x8(v *Value) bool { return true } } -func rewriteValueS390X_OpS390XADD(v *Value) bool { +func rewriteValueS390X_OpS390XADD_0(v *Value) bool { // match: (ADD x (MOVDconst [c])) // cond: is32Bit(c) // result: (ADDconst [c] x) @@ -5907,6 +5914,9 @@ func rewriteValueS390X_OpS390XADD(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XADD_10(v *Value) bool { // match: (ADD g:(MOVDload [off] {sym} ptr mem) x) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (ADDload [off] {sym} x ptr mem) @@ -5961,7 +5971,7 @@ func rewriteValueS390X_OpS390XADD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XADDW(v *Value) bool { +func rewriteValueS390X_OpS390XADDW_0(v *Value) bool { // match: (ADDW x (MOVDconst [c])) // cond: // result: (ADDWconst [c] x) @@ -6178,6 +6188,9 @@ func rewriteValueS390X_OpS390XADDW(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XADDW_10(v *Value) bool { // match: (ADDW x g:(MOVWZload [off] {sym} ptr mem)) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (ADDWload [off] {sym} x ptr mem) @@ -6284,7 +6297,7 @@ func rewriteValueS390X_OpS390XADDW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XADDWconst(v *Value) bool { +func rewriteValueS390X_OpS390XADDWconst_0(v *Value) bool { // match: (ADDWconst [c] x) // cond: int32(c)==0 // result: x @@ -6331,7 +6344,7 @@ func rewriteValueS390X_OpS390XADDWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XADDconst(v *Value) bool { +func rewriteValueS390X_OpS390XADDconst_0(v *Value) bool { // match: (ADDconst [c] (MOVDaddr [d] {s} x:(SB))) // cond: ((c+d)&1 == 0) && is32Bit(c+d) // result: (MOVDaddr [c+d] {s} x) @@ -6448,7 +6461,7 @@ func rewriteValueS390X_OpS390XADDconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XAND(v *Value) bool { +func rewriteValueS390X_OpS390XAND_0(v *Value) bool { // match: (AND x (MOVDconst [c])) // cond: is32Bit(c) && c < 0 // result: (ANDconst [c] x) @@ -6617,6 +6630,9 @@ func rewriteValueS390X_OpS390XAND(v *Value) bool { v.AuxInt = c & d return true } + return false +} +func rewriteValueS390X_OpS390XAND_10(v *Value) bool { // match: (AND x x) // cond: // result: x @@ -6736,7 +6752,7 @@ func rewriteValueS390X_OpS390XAND(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XANDW(v *Value) bool { +func rewriteValueS390X_OpS390XANDW_0(v *Value) bool { // match: (ANDW x (MOVDconst [c])) // cond: // result: (ANDWconst [c] x) @@ -6962,6 +6978,9 @@ func rewriteValueS390X_OpS390XANDW(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XANDW_10(v *Value) bool { // match: (ANDW x g:(MOVWZload [off] {sym} ptr mem)) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (ANDWload [off] {sym} x ptr mem) @@ -6990,7 +7009,7 @@ func rewriteValueS390X_OpS390XANDW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XANDWconst(v *Value) bool { +func rewriteValueS390X_OpS390XANDWconst_0(v *Value) bool { // match: (ANDWconst [c] (ANDWconst [d] x)) // cond: // result: (ANDWconst [c & d] x) @@ -7073,7 +7092,7 @@ func rewriteValueS390X_OpS390XANDWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XANDconst(v *Value) bool { +func rewriteValueS390X_OpS390XANDconst_0(v *Value) bool { // match: (ANDconst [c] (ANDconst [d] x)) // cond: // result: (ANDconst [c & d] x) @@ -7130,7 +7149,7 @@ func rewriteValueS390X_OpS390XANDconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMP(v *Value) bool { +func rewriteValueS390X_OpS390XCMP_0(v *Value) bool { b := v.Block _ = b // match: (CMP x (MOVDconst [c])) @@ -7173,7 +7192,7 @@ func rewriteValueS390X_OpS390XCMP(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPU(v *Value) bool { +func rewriteValueS390X_OpS390XCMPU_0(v *Value) bool { b := v.Block _ = b // match: (CMPU x (MOVDconst [c])) @@ -7216,7 +7235,7 @@ func rewriteValueS390X_OpS390XCMPU(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool { +func rewriteValueS390X_OpS390XCMPUconst_0(v *Value) bool { // match: (CMPUconst (MOVDconst [x]) [y]) // cond: uint64(x)==uint64(y) // result: (FlagEQ) @@ -7267,7 +7286,7 @@ func rewriteValueS390X_OpS390XCMPUconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPW(v *Value) bool { +func rewriteValueS390X_OpS390XCMPW_0(v *Value) bool { b := v.Block _ = b // match: (CMPW x (MOVDconst [c])) @@ -7304,7 +7323,7 @@ func rewriteValueS390X_OpS390XCMPW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPWU(v *Value) bool { +func rewriteValueS390X_OpS390XCMPWU_0(v *Value) bool { b := v.Block _ = b // match: (CMPWU x (MOVDconst [c])) @@ -7341,7 +7360,7 @@ func rewriteValueS390X_OpS390XCMPWU(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool { +func rewriteValueS390X_OpS390XCMPWUconst_0(v *Value) bool { // match: (CMPWUconst (MOVDconst [x]) [y]) // cond: uint32(x)==uint32(y) // result: (FlagEQ) @@ -7392,7 +7411,7 @@ func rewriteValueS390X_OpS390XCMPWUconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool { +func rewriteValueS390X_OpS390XCMPWconst_0(v *Value) bool { // match: (CMPWconst (MOVDconst [x]) [y]) // cond: int32(x)==int32(y) // result: (FlagEQ) @@ -7475,7 +7494,7 @@ func rewriteValueS390X_OpS390XCMPWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XCMPconst(v *Value) bool { +func rewriteValueS390X_OpS390XCMPconst_0(v *Value) bool { // match: (CMPconst (MOVDconst [x]) [y]) // cond: x==y // result: (FlagEQ) @@ -7603,7 +7622,7 @@ func rewriteValueS390X_OpS390XCMPconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFADD(v *Value) bool { +func rewriteValueS390X_OpS390XFADD_0(v *Value) bool { // match: (FADD (FMUL y z) x) // cond: // result: (FMADD x y z) @@ -7640,7 +7659,7 @@ func rewriteValueS390X_OpS390XFADD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFADDS(v *Value) bool { +func rewriteValueS390X_OpS390XFADDS_0(v *Value) bool { // match: (FADDS (FMULS y z) x) // cond: // result: (FMADDS x y z) @@ -7677,7 +7696,7 @@ func rewriteValueS390X_OpS390XFADDS(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVDload_0(v *Value) bool { // match: (FMOVDload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (FMOVDload [off1+off2] {sym} ptr mem) @@ -7777,7 +7796,7 @@ func rewriteValueS390X_OpS390XFMOVDload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVDloadidx_0(v *Value) bool { // match: (FMOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (FMOVDloadidx [c+d] {sym} ptr idx mem) @@ -7824,7 +7843,7 @@ func rewriteValueS390X_OpS390XFMOVDloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVDstore_0(v *Value) bool { // match: (FMOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (FMOVDstore [off1+off2] {sym} ptr val mem) @@ -7932,7 +7951,7 @@ func rewriteValueS390X_OpS390XFMOVDstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVDstoreidx_0(v *Value) bool { // match: (FMOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (FMOVDstoreidx [c+d] {sym} ptr idx val mem) @@ -7983,7 +8002,7 @@ func rewriteValueS390X_OpS390XFMOVDstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVSload_0(v *Value) bool { // match: (FMOVSload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (FMOVSload [off1+off2] {sym} ptr mem) @@ -8083,7 +8102,7 @@ func rewriteValueS390X_OpS390XFMOVSload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVSloadidx_0(v *Value) bool { // match: (FMOVSloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (FMOVSloadidx [c+d] {sym} ptr idx mem) @@ -8130,7 +8149,7 @@ func rewriteValueS390X_OpS390XFMOVSloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVSstore_0(v *Value) bool { // match: (FMOVSstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (FMOVSstore [off1+off2] {sym} ptr val mem) @@ -8238,7 +8257,7 @@ func rewriteValueS390X_OpS390XFMOVSstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XFMOVSstoreidx_0(v *Value) bool { // match: (FMOVSstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (FMOVSstoreidx [c+d] {sym} ptr idx val mem) @@ -8289,7 +8308,7 @@ func rewriteValueS390X_OpS390XFMOVSstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFSUB(v *Value) bool { +func rewriteValueS390X_OpS390XFSUB_0(v *Value) bool { // match: (FSUB (FMUL y z) x) // cond: // result: (FMSUB x y z) @@ -8309,7 +8328,7 @@ func rewriteValueS390X_OpS390XFSUB(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XFSUBS(v *Value) bool { +func rewriteValueS390X_OpS390XFSUBS_0(v *Value) bool { // match: (FSUBS (FMULS y z) x) // cond: // result: (FMSUBS x y z) @@ -8329,7 +8348,7 @@ func rewriteValueS390X_OpS390XFSUBS(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool { +func rewriteValueS390X_OpS390XLoweredRound32F_0(v *Value) bool { // match: (LoweredRound32F x:(FMOVSconst)) // cond: // result: x @@ -8345,7 +8364,7 @@ func rewriteValueS390X_OpS390XLoweredRound32F(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool { +func rewriteValueS390X_OpS390XLoweredRound64F_0(v *Value) bool { // match: (LoweredRound64F x:(FMOVDconst)) // cond: // result: x @@ -8361,7 +8380,7 @@ func rewriteValueS390X_OpS390XLoweredRound64F(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBZload_0(v *Value) bool { // match: (MOVBZload [off] {sym} ptr (MOVBstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVBZreg x) @@ -8483,7 +8502,7 @@ func rewriteValueS390X_OpS390XMOVBZload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBZloadidx_0(v *Value) bool { // match: (MOVBZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVBZloadidx [c+d] {sym} ptr idx mem) @@ -8574,9 +8593,7 @@ func rewriteValueS390X_OpS390XMOVBZloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVBZreg_0(v *Value) bool { // match: (MOVBZreg x:(MOVDLT (MOVDconst [c]) (MOVDconst [d]) _)) // cond: int64(uint8(c)) == c && int64(uint8(d)) == d // result: (MOVDreg x) @@ -8805,6 +8822,11 @@ func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueS390X_OpS390XMOVBZreg_10(v *Value) bool { + b := v.Block + _ = b // match: (MOVBZreg x:(MOVBZreg _)) // cond: // result: (MOVDreg x) @@ -8884,7 +8906,7 @@ func rewriteValueS390X_OpS390XMOVBZreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBload_0(v *Value) bool { // match: (MOVBload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVBload [off1+off2] {sym} ptr mem) @@ -8934,7 +8956,7 @@ func rewriteValueS390X_OpS390XMOVBload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVBreg x:(MOVBload _ _)) @@ -9017,7 +9039,7 @@ func rewriteValueS390X_OpS390XMOVBreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBstore_0(v *Value) bool { // match: (MOVBstore [off] {sym} ptr (MOVBreg x) mem) // cond: // result: (MOVBstore [off] {sym} ptr x mem) @@ -9322,6 +9344,9 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVBstore_10(v *Value) bool { // match: (MOVBstore [i] {s} p w0:(SRWconst [j] w) x:(MOVBstore [i-1] {s} p (SRWconst [j+8] w) mem)) // cond: p.Op != OpSB && x.Uses == 1 && clobber(x) // result: (MOVHstore [i-1] {s} p w0 mem) @@ -9554,7 +9579,7 @@ func rewriteValueS390X_OpS390XMOVBstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBstoreconst_0(v *Value) bool { // match: (MOVBstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVBstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -9633,7 +9658,7 @@ func rewriteValueS390X_OpS390XMOVBstoreconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVBstoreidx_0(v *Value) bool { // match: (MOVBstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVBstoreidx [c+d] {sym} ptr idx val mem) @@ -10028,6 +10053,9 @@ func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVBstoreidx_10(v *Value) bool { // match: (MOVBstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVBstoreidx [i-1] {s} p idx (SRDconst [j+8] w) mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVHstoreidx [i-1] {s} p idx w0 mem) @@ -10538,6 +10566,9 @@ func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVBstoreidx_20(v *Value) bool { // match: (MOVBstoreidx [i] {s} p idx (SRDconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVHBRstoreidx [i-1] {s} p idx w mem) @@ -11038,6 +11069,9 @@ func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVBstoreidx_30(v *Value) bool { // match: (MOVBstoreidx [i] {s} idx p (SRWconst [8] w) x:(MOVBstoreidx [i-1] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVHBRstoreidx [i-1] {s} p idx w mem) @@ -11348,7 +11382,7 @@ func rewriteValueS390X_OpS390XMOVBstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDEQ_0(v *Value) bool { // match: (MOVDEQ x y (InvertFlags cmp)) // cond: // result: (MOVDEQ x y cmp) @@ -11410,7 +11444,7 @@ func rewriteValueS390X_OpS390XMOVDEQ(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDGE_0(v *Value) bool { // match: (MOVDGE x y (InvertFlags cmp)) // cond: // result: (MOVDLE x y cmp) @@ -11472,7 +11506,7 @@ func rewriteValueS390X_OpS390XMOVDGE(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDGT_0(v *Value) bool { // match: (MOVDGT x y (InvertFlags cmp)) // cond: // result: (MOVDLT x y cmp) @@ -11534,7 +11568,7 @@ func rewriteValueS390X_OpS390XMOVDGT(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDLE_0(v *Value) bool { // match: (MOVDLE x y (InvertFlags cmp)) // cond: // result: (MOVDGE x y cmp) @@ -11596,7 +11630,7 @@ func rewriteValueS390X_OpS390XMOVDLE(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDLT_0(v *Value) bool { // match: (MOVDLT x y (InvertFlags cmp)) // cond: // result: (MOVDGT x y cmp) @@ -11658,7 +11692,7 @@ func rewriteValueS390X_OpS390XMOVDLT(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDNE_0(v *Value) bool { // match: (MOVDNE x y (InvertFlags cmp)) // cond: // result: (MOVDNE x y cmp) @@ -11720,7 +11754,7 @@ func rewriteValueS390X_OpS390XMOVDNE(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDaddridx_0(v *Value) bool { // match: (MOVDaddridx [c] {s} (ADDconst [d] x) y) // cond: is20Bit(c+d) && x.Op != OpSB // result: (MOVDaddridx [c+d] {s} x y) @@ -11817,7 +11851,7 @@ func rewriteValueS390X_OpS390XMOVDaddridx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDload_0(v *Value) bool { // match: (MOVDload [off] {sym} ptr (MOVDstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVDreg x) @@ -11939,7 +11973,7 @@ func rewriteValueS390X_OpS390XMOVDload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDloadidx_0(v *Value) bool { // match: (MOVDloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVDloadidx [c+d] {sym} ptr idx mem) @@ -12030,7 +12064,7 @@ func rewriteValueS390X_OpS390XMOVDloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDnop_0(v *Value) bool { b := v.Block _ = b // match: (MOVDnop x) @@ -12270,6 +12304,11 @@ func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVDnop_10(v *Value) bool { + b := v.Block + _ = b // match: (MOVDnop x:(MOVHZloadidx [off] {sym} ptr idx mem)) // cond: x.Uses == 1 && clobber(x) // result: @x.Block (MOVHZloadidx [off] {sym} ptr idx mem) @@ -12356,7 +12395,7 @@ func rewriteValueS390X_OpS390XMOVDnop(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVDreg x) @@ -12580,6 +12619,11 @@ func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVDreg_10(v *Value) bool { + b := v.Block + _ = b // match: (MOVDreg x:(MOVBZloadidx [off] {sym} ptr idx mem)) // cond: x.Uses == 1 && clobber(x) // result: @x.Block (MOVBZloadidx [off] {sym} ptr idx mem) @@ -12694,7 +12738,7 @@ func rewriteValueS390X_OpS390XMOVDreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDstore_0(v *Value) bool { // match: (MOVDstore [off1] {sym} (ADDconst [off2] ptr) val mem) // cond: is20Bit(off1+off2) // result: (MOVDstore [off1+off2] {sym} ptr val mem) @@ -12936,7 +12980,7 @@ func rewriteValueS390X_OpS390XMOVDstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDstoreconst_0(v *Value) bool { // match: (MOVDstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVDstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -12986,7 +13030,7 @@ func rewriteValueS390X_OpS390XMOVDstoreconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVDstoreidx_0(v *Value) bool { // match: (MOVDstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVDstoreidx [c+d] {sym} ptr idx val mem) @@ -13085,7 +13129,7 @@ func rewriteValueS390X_OpS390XMOVDstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHBRstore_0(v *Value) bool { // match: (MOVHBRstore [i] {s} p (SRDconst [16] w) x:(MOVHBRstore [i-2] {s} p w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWBRstore [i-2] {s} p w mem) @@ -13270,7 +13314,7 @@ func rewriteValueS390X_OpS390XMOVHBRstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHBRstoreidx_0(v *Value) bool { // match: (MOVHBRstoreidx [i] {s} p idx (SRDconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWBRstoreidx [i-2] {s} p idx w mem) @@ -13771,6 +13815,9 @@ func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVHBRstoreidx_10(v *Value) bool { // match: (MOVHBRstoreidx [i] {s} idx p (SRWconst [16] w) x:(MOVHBRstoreidx [i-2] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWBRstoreidx [i-2] {s} p idx w mem) @@ -14081,7 +14128,7 @@ func rewriteValueS390X_OpS390XMOVHBRstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHZload_0(v *Value) bool { // match: (MOVHZload [off] {sym} ptr (MOVHstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVHZreg x) @@ -14203,7 +14250,7 @@ func rewriteValueS390X_OpS390XMOVHZload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHZloadidx_0(v *Value) bool { // match: (MOVHZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVHZloadidx [c+d] {sym} ptr idx mem) @@ -14294,7 +14341,7 @@ func rewriteValueS390X_OpS390XMOVHZloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHZreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVHZreg x:(MOVBZload _ _)) @@ -14428,7 +14475,7 @@ func rewriteValueS390X_OpS390XMOVHZreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHload_0(v *Value) bool { // match: (MOVHload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVHload [off1+off2] {sym} ptr mem) @@ -14478,7 +14525,7 @@ func rewriteValueS390X_OpS390XMOVHload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVHreg x:(MOVBload _ _)) @@ -14609,7 +14656,7 @@ func rewriteValueS390X_OpS390XMOVHreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHstore_0(v *Value) bool { // match: (MOVHstore [off] {sym} ptr (MOVHreg x) mem) // cond: // result: (MOVHstore [off] {sym} ptr x mem) @@ -14914,6 +14961,9 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVHstore_10(v *Value) bool { // match: (MOVHstore [i] {s} p w0:(SRWconst [j] w) x:(MOVHstore [i-2] {s} p (SRWconst [j+16] w) mem)) // cond: p.Op != OpSB && x.Uses == 1 && clobber(x) // result: (MOVWstore [i-2] {s} p w0 mem) @@ -14964,7 +15014,7 @@ func rewriteValueS390X_OpS390XMOVHstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHstoreconst_0(v *Value) bool { // match: (MOVHstoreconst [sc] {s} (ADDconst [off] ptr) mem) // cond: ValAndOff(sc).canAdd(off) // result: (MOVHstoreconst [ValAndOff(sc).add(off)] {s} ptr mem) @@ -15043,7 +15093,7 @@ func rewriteValueS390X_OpS390XMOVHstoreconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVHstoreidx_0(v *Value) bool { // match: (MOVHstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVHstoreidx [c+d] {sym} ptr idx val mem) @@ -15438,6 +15488,9 @@ func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVHstoreidx_10(v *Value) bool { // match: (MOVHstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVHstoreidx [i-2] {s} p idx (SRDconst [j+16] w) mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVWstoreidx [i-2] {s} p idx w0 mem) @@ -15950,7 +16003,7 @@ func rewriteValueS390X_OpS390XMOVHstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWBRstore_0(v *Value) bool { // match: (MOVWBRstore [i] {s} p (SRDconst [32] w) x:(MOVWBRstore [i-4] {s} p w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVDBRstore [i-4] {s} p w mem) @@ -16044,7 +16097,7 @@ func rewriteValueS390X_OpS390XMOVWBRstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWBRstoreidx_0(v *Value) bool { // match: (MOVWBRstoreidx [i] {s} p idx (SRDconst [32] w) x:(MOVWBRstoreidx [i-4] {s} p idx w mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVDBRstoreidx [i-4] {s} p idx w mem) @@ -16451,7 +16504,7 @@ func rewriteValueS390X_OpS390XMOVWBRstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWZload_0(v *Value) bool { // match: (MOVWZload [off] {sym} ptr (MOVWstore [off2] {sym2} ptr2 x _)) // cond: sym == sym2 && off == off2 && isSamePtr(ptr, ptr2) // result: (MOVWZreg x) @@ -16573,7 +16626,7 @@ func rewriteValueS390X_OpS390XMOVWZload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWZloadidx_0(v *Value) bool { // match: (MOVWZloadidx [c] {sym} (ADDconst [d] ptr) idx mem) // cond: // result: (MOVWZloadidx [c+d] {sym} ptr idx mem) @@ -16664,7 +16717,7 @@ func rewriteValueS390X_OpS390XMOVWZloadidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWZreg_0(v *Value) bool { b := v.Block _ = b // match: (MOVWZreg x:(MOVBZload _ _)) @@ -16822,7 +16875,7 @@ func rewriteValueS390X_OpS390XMOVWZreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWload(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWload_0(v *Value) bool { // match: (MOVWload [off1] {sym} (ADDconst [off2] ptr) mem) // cond: is20Bit(off1+off2) // result: (MOVWload [off1+off2] {sym} ptr mem) @@ -16872,9 +16925,7 @@ func rewriteValueS390X_OpS390XMOVWload(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool { - b := v.Block - _ = b +func rewriteValueS390X_OpS390XMOVWreg_0(v *Value) bool { // match: (MOVWreg x:(MOVBload _ _)) // cond: // result: (MOVDreg x) @@ -16999,6 +17050,11 @@ func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValueS390X_OpS390XMOVWreg_10(v *Value) bool { + b := v.Block + _ = b // match: (MOVWreg x:(MOVWreg _)) // cond: // result: (MOVDreg x) @@ -17051,7 +17107,7 @@ func rewriteValueS390X_OpS390XMOVWreg(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWstore_0(v *Value) bool { // match: (MOVWstore [off] {sym} ptr (MOVWreg x) mem) // cond: // result: (MOVWstore [off] {sym} ptr x mem) @@ -17348,6 +17404,9 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVWstore_10(v *Value) bool { // match: (MOVWstore [i] {s} p w2 x:(STM2 [i-8] {s} p w0 w1 mem)) // cond: x.Uses == 1 && is20Bit(i-8) && clobber(x) // result: (STM3 [i-8] {s} p w0 w1 w2 mem) @@ -17426,7 +17485,7 @@ func rewriteValueS390X_OpS390XMOVWstore(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWstoreconst_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -17512,7 +17571,7 @@ func rewriteValueS390X_OpS390XMOVWstoreconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool { +func rewriteValueS390X_OpS390XMOVWstoreidx_0(v *Value) bool { // match: (MOVWstoreidx [c] {sym} (ADDconst [d] ptr) idx val mem) // cond: // result: (MOVWstoreidx [c+d] {sym} ptr idx val mem) @@ -17907,6 +17966,9 @@ func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XMOVWstoreidx_10(v *Value) bool { // match: (MOVWstoreidx [i] {s} idx p w0:(SRDconst [j] w) x:(MOVWstoreidx [i-4] {s} p idx (SRDconst [j+32] w) mem)) // cond: x.Uses == 1 && clobber(x) // result: (MOVDstoreidx [i-4] {s} p idx w0 mem) @@ -18015,7 +18077,7 @@ func rewriteValueS390X_OpS390XMOVWstoreidx(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMULLD(v *Value) bool { +func rewriteValueS390X_OpS390XMULLD_0(v *Value) bool { // match: (MULLD x (MOVDconst [c])) // cond: is32Bit(c) // result: (MULLDconst [c] x) @@ -18158,7 +18220,7 @@ func rewriteValueS390X_OpS390XMULLD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool { +func rewriteValueS390X_OpS390XMULLDconst_0(v *Value) bool { b := v.Block _ = b // match: (MULLDconst [-1] x) @@ -18261,7 +18323,7 @@ func rewriteValueS390X_OpS390XMULLDconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMULLW(v *Value) bool { +func rewriteValueS390X_OpS390XMULLW_0(v *Value) bool { // match: (MULLW x (MOVDconst [c])) // cond: // result: (MULLWconst [c] x) @@ -18502,7 +18564,7 @@ func rewriteValueS390X_OpS390XMULLW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool { +func rewriteValueS390X_OpS390XMULLWconst_0(v *Value) bool { b := v.Block _ = b // match: (MULLWconst [-1] x) @@ -18605,7 +18667,7 @@ func rewriteValueS390X_OpS390XMULLWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XNEG(v *Value) bool { +func rewriteValueS390X_OpS390XNEG_0(v *Value) bool { // match: (NEG (MOVDconst [c])) // cond: // result: (MOVDconst [-c]) @@ -18643,7 +18705,7 @@ func rewriteValueS390X_OpS390XNEG(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XNEGW(v *Value) bool { +func rewriteValueS390X_OpS390XNEGW_0(v *Value) bool { // match: (NEGW (MOVDconst [c])) // cond: // result: (MOVDconst [int64(int32(-c))]) @@ -18659,7 +18721,7 @@ func rewriteValueS390X_OpS390XNEGW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XNOT(v *Value) bool { +func rewriteValueS390X_OpS390XNOT_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -18681,7 +18743,7 @@ func rewriteValueS390X_OpS390XNOT(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XNOTW(v *Value) bool { +func rewriteValueS390X_OpS390XNOTW_0(v *Value) bool { // match: (NOTW x) // cond: true // result: (XORWconst [-1] x) @@ -18697,11 +18759,7 @@ func rewriteValueS390X_OpS390XNOTW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XOR(v *Value) bool { - b := v.Block - _ = b - types := &b.Func.Config.Types - _ = types +func rewriteValueS390X_OpS390XOR_0(v *Value) bool { // match: (OR x (MOVDconst [c])) // cond: isU32Bit(c) // result: (ORconst [c] x) @@ -18917,6 +18975,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 x g:(MOVDload [off] {sym} ptr mem)) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (ORload [off] {sym} x ptr mem) @@ -19399,6 +19464,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j1] (MOVHZload [i0] {s} p mem)) y) @@ -19954,6 +20026,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XOR_30(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (OR sh:(SLDconst [8] x0:(MOVBZloadidx [i0] {s} idx p mem)) x1:(MOVBZloadidx [i1] {s} p idx mem)) // cond: i1 == i0+1 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVHZloadidx [i0] {s} p idx mem) @@ -20464,6 +20543,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XOR_40(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (OR sh:(SLDconst [16] x0:(MOVHZloadidx [i0] {s} idx p mem)) x1:(MOVHZloadidx [i1] {s} idx p mem)) // cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem) @@ -20988,6 +21074,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j1] (MOVHZloadidx [i0] {s} p idx mem)) y) @@ -21638,6 +21731,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j1] (MOVHZloadidx [i0] {s} p idx mem)) y) @@ -22288,6 +22388,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j1] (MOVWZloadidx [i0] {s} p idx mem)) y) @@ -22938,6 +23045,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j1] (MOVWZloadidx [i0] {s} p idx mem)) y) @@ -23505,6 +23619,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y) @@ -24112,6 +24233,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { v0.AddArg(v1) return true } + return false +} +func rewriteValueS390X_OpS390XOR_100(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (OR sh:(SLDconst [8] x1:(MOVBZloadidx [i1] {s} idx p mem)) x0:(MOVBZloadidx [i0] {s} p idx mem)) // cond: p.Op != OpSB && i1 == i0+1 && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem)) @@ -24698,6 +24826,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { v0.AddArg(v1) return true } + return false +} +func rewriteValueS390X_OpS390XOR_110(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (OR sh:(SLDconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} idx p mem))) r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem))) // cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem)) @@ -25298,6 +25433,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y) @@ -25968,6 +26110,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y) @@ -26678,6 +26827,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y) @@ -27428,6 +27584,13 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { 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 (SLDconst [j0] (MOVWZreg (MOVWBRloadidx [i0] {s} p idx mem))) y) @@ -27505,11 +27668,7 @@ func rewriteValueS390X_OpS390XOR(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XORW(v *Value) bool { - b := v.Block - _ = b - types := &b.Func.Config.Types - _ = types +func rewriteValueS390X_OpS390XORW_0(v *Value) bool { // match: (ORW x (MOVDconst [c])) // cond: // result: (ORWconst [c] x) @@ -27735,6 +27894,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 g:(MOVWZload [off] {sym} ptr mem) x) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (ORWload [off] {sym} x ptr mem) @@ -28177,6 +28343,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j1] (MOVHZload [i0] {s} p mem)) y) @@ -28696,6 +28869,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XORW_30(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORW x1:(MOVHZloadidx [i1] {s} idx p mem) sh:(SLWconst [16] x0:(MOVHZloadidx [i0] {s} p idx mem))) // cond: i1 == i0+2 && p.Op != OpSB && x0.Uses == 1 && x1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVWZloadidx [i0] {s} p idx mem) @@ -29248,6 +29428,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j1] (MOVHZloadidx [i0] {s} p idx mem)) y) @@ -29898,6 +30085,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j1] (MOVHZloadidx [i0] {s} p idx mem)) y) @@ -30483,6 +30677,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j0] (MOVHZreg (MOVHBRload [i0] {s} p mem))) y) @@ -31028,6 +31229,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { v0.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XORW_70(v *Value) bool { + b := v.Block + _ = b + types := &b.Func.Config.Types + _ = types // match: (ORW r0:(MOVHZreg x0:(MOVHBRloadidx [i0] {s} idx p mem)) sh:(SLWconst [16] r1:(MOVHZreg x1:(MOVHBRloadidx [i1] {s} p idx mem)))) // cond: i1 == i0+2 && x0.Uses == 1 && x1.Uses == 1 && r0.Uses == 1 && r1.Uses == 1 && sh.Uses == 1 && mergePoint(b,x0,x1) != nil && clobber(x0) && clobber(x1) && clobber(r0) && clobber(r1) && clobber(sh) // result: @mergePoint(b,x0,x1) (MOVWBRloadidx [i0] {s} p idx mem) @@ -31642,6 +31850,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y) @@ -32312,6 +32527,13 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { 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 (SLWconst [j0] (MOVHZreg (MOVHBRloadidx [i0] {s} p idx mem))) y) @@ -32515,7 +32737,7 @@ func rewriteValueS390X_OpS390XORW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XORWconst(v *Value) bool { +func rewriteValueS390X_OpS390XORWconst_0(v *Value) bool { // match: (ORWconst [c] x) // cond: int32(c)==0 // result: x @@ -32558,7 +32780,7 @@ func rewriteValueS390X_OpS390XORWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XORconst(v *Value) bool { +func rewriteValueS390X_OpS390XORconst_0(v *Value) bool { // match: (ORconst [0] x) // cond: // result: x @@ -32599,7 +32821,7 @@ func rewriteValueS390X_OpS390XORconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSLD(v *Value) bool { +func rewriteValueS390X_OpS390XSLD_0(v *Value) bool { // match: (SLD x (MOVDconst [c])) // cond: // result: (SLDconst [c&63] x) @@ -32635,7 +32857,7 @@ func rewriteValueS390X_OpS390XSLD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSLW(v *Value) bool { +func rewriteValueS390X_OpS390XSLW_0(v *Value) bool { // match: (SLW x (MOVDconst [c])) // cond: // result: (SLWconst [c&63] x) @@ -32671,7 +32893,7 @@ func rewriteValueS390X_OpS390XSLW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRAD(v *Value) bool { +func rewriteValueS390X_OpS390XSRAD_0(v *Value) bool { // match: (SRAD x (MOVDconst [c])) // cond: // result: (SRADconst [c&63] x) @@ -32707,7 +32929,7 @@ func rewriteValueS390X_OpS390XSRAD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRADconst(v *Value) bool { +func rewriteValueS390X_OpS390XSRADconst_0(v *Value) bool { // match: (SRADconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [d>>uint64(c)]) @@ -32724,7 +32946,7 @@ func rewriteValueS390X_OpS390XSRADconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRAW(v *Value) bool { +func rewriteValueS390X_OpS390XSRAW_0(v *Value) bool { // match: (SRAW x (MOVDconst [c])) // cond: // result: (SRAWconst [c&63] x) @@ -32760,7 +32982,7 @@ func rewriteValueS390X_OpS390XSRAW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool { +func rewriteValueS390X_OpS390XSRAWconst_0(v *Value) bool { // match: (SRAWconst [c] (MOVDconst [d])) // cond: // result: (MOVDconst [d>>uint64(c)]) @@ -32777,7 +32999,7 @@ func rewriteValueS390X_OpS390XSRAWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRD(v *Value) bool { +func rewriteValueS390X_OpS390XSRD_0(v *Value) bool { // match: (SRD x (MOVDconst [c])) // cond: // result: (SRDconst [c&63] x) @@ -32813,7 +33035,7 @@ func rewriteValueS390X_OpS390XSRD(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSRW(v *Value) bool { +func rewriteValueS390X_OpS390XSRW_0(v *Value) bool { // match: (SRW x (MOVDconst [c])) // cond: // result: (SRWconst [c&63] x) @@ -32849,7 +33071,7 @@ func rewriteValueS390X_OpS390XSRW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSTM2(v *Value) bool { +func rewriteValueS390X_OpS390XSTM2_0(v *Value) bool { // match: (STM2 [i] {s} p w2 w3 x:(STM2 [i-8] {s} p w0 w1 mem)) // cond: x.Uses == 1 && is20Bit(i-8) && clobber(x) // result: (STM4 [i-8] {s} p w0 w1 w2 w3 mem) @@ -32918,7 +33140,7 @@ func rewriteValueS390X_OpS390XSTM2(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSTMG2(v *Value) bool { +func rewriteValueS390X_OpS390XSTMG2_0(v *Value) bool { // match: (STMG2 [i] {s} p w2 w3 x:(STMG2 [i-16] {s} p w0 w1 mem)) // cond: x.Uses == 1 && is20Bit(i-16) && clobber(x) // result: (STMG4 [i-16] {s} p w0 w1 w2 w3 mem) @@ -32960,7 +33182,7 @@ func rewriteValueS390X_OpS390XSTMG2(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSUB(v *Value) bool { +func rewriteValueS390X_OpS390XSUB_0(v *Value) bool { b := v.Block _ = b // match: (SUB x (MOVDconst [c])) @@ -33041,7 +33263,7 @@ func rewriteValueS390X_OpS390XSUB(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool { +func rewriteValueS390X_OpS390XSUBEWcarrymask_0(v *Value) bool { // match: (SUBEWcarrymask (FlagEQ)) // cond: // result: (MOVDconst [-1]) @@ -33080,7 +33302,7 @@ func rewriteValueS390X_OpS390XSUBEWcarrymask(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool { +func rewriteValueS390X_OpS390XSUBEcarrymask_0(v *Value) bool { // match: (SUBEcarrymask (FlagEQ)) // cond: // result: (MOVDconst [-1]) @@ -33119,7 +33341,7 @@ func rewriteValueS390X_OpS390XSUBEcarrymask(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSUBW(v *Value) bool { +func rewriteValueS390X_OpS390XSUBW_0(v *Value) bool { b := v.Block _ = b // match: (SUBW x (MOVDconst [c])) @@ -33220,7 +33442,7 @@ func rewriteValueS390X_OpS390XSUBW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool { +func rewriteValueS390X_OpS390XSUBWconst_0(v *Value) bool { // match: (SUBWconst [c] x) // cond: int32(c) == 0 // result: x @@ -33247,7 +33469,7 @@ func rewriteValueS390X_OpS390XSUBWconst(v *Value) bool { return true } } -func rewriteValueS390X_OpS390XSUBconst(v *Value) bool { +func rewriteValueS390X_OpS390XSUBconst_0(v *Value) bool { // match: (SUBconst [0] x) // cond: // result: x @@ -33310,7 +33532,7 @@ func rewriteValueS390X_OpS390XSUBconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XXOR(v *Value) bool { +func rewriteValueS390X_OpS390XXOR_0(v *Value) bool { // match: (XOR x (MOVDconst [c])) // cond: isU32Bit(c) // result: (XORconst [c] x) @@ -33525,6 +33747,9 @@ func rewriteValueS390X_OpS390XXOR(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XXOR_10(v *Value) bool { // match: (XOR x g:(MOVDload [off] {sym} ptr mem)) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (XORload [off] {sym} x ptr mem) @@ -33553,7 +33778,7 @@ func rewriteValueS390X_OpS390XXOR(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XXORW(v *Value) bool { +func rewriteValueS390X_OpS390XXORW_0(v *Value) bool { // match: (XORW x (MOVDconst [c])) // cond: // result: (XORWconst [c] x) @@ -33778,6 +34003,9 @@ func rewriteValueS390X_OpS390XXORW(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValueS390X_OpS390XXORW_10(v *Value) bool { // match: (XORW g:(MOVWZload [off] {sym} ptr mem) x) // cond: ptr.Op != OpSB && is20Bit(off) && canMergeLoad(v, g, x) && clobber(g) // result: (XORWload [off] {sym} x ptr mem) @@ -33858,7 +34086,7 @@ func rewriteValueS390X_OpS390XXORW(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XXORWconst(v *Value) bool { +func rewriteValueS390X_OpS390XXORWconst_0(v *Value) bool { // match: (XORWconst [c] x) // cond: int32(c)==0 // result: x @@ -33889,7 +34117,7 @@ func rewriteValueS390X_OpS390XXORWconst(v *Value) bool { } return false } -func rewriteValueS390X_OpS390XXORconst(v *Value) bool { +func rewriteValueS390X_OpS390XXORconst_0(v *Value) bool { // match: (XORconst [0] x) // cond: // result: x @@ -33919,7 +34147,7 @@ func rewriteValueS390X_OpS390XXORconst(v *Value) bool { } return false } -func rewriteValueS390X_OpSelect0(v *Value) bool { +func rewriteValueS390X_OpSelect0_0(v *Value) bool { b := v.Block _ = b // match: (Select0 (AddTupleFirst32 tuple val)) @@ -33960,7 +34188,7 @@ func rewriteValueS390X_OpSelect0(v *Value) bool { } return false } -func rewriteValueS390X_OpSelect1(v *Value) bool { +func rewriteValueS390X_OpSelect1_0(v *Value) bool { // match: (Select1 (AddTupleFirst32 tuple _)) // cond: // result: (Select1 tuple) @@ -33989,7 +34217,7 @@ func rewriteValueS390X_OpSelect1(v *Value) bool { } return false } -func rewriteValueS390X_OpSignExt16to32(v *Value) bool { +func rewriteValueS390X_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 x) // cond: // result: (MOVHreg x) @@ -34000,7 +34228,7 @@ func rewriteValueS390X_OpSignExt16to32(v *Value) bool { return true } } -func rewriteValueS390X_OpSignExt16to64(v *Value) bool { +func rewriteValueS390X_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 x) // cond: // result: (MOVHreg x) @@ -34011,7 +34239,7 @@ func rewriteValueS390X_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValueS390X_OpSignExt32to64(v *Value) bool { +func rewriteValueS390X_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 x) // cond: // result: (MOVWreg x) @@ -34022,7 +34250,7 @@ func rewriteValueS390X_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValueS390X_OpSignExt8to16(v *Value) bool { +func rewriteValueS390X_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 x) // cond: // result: (MOVBreg x) @@ -34033,7 +34261,7 @@ func rewriteValueS390X_OpSignExt8to16(v *Value) bool { return true } } -func rewriteValueS390X_OpSignExt8to32(v *Value) bool { +func rewriteValueS390X_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 x) // cond: // result: (MOVBreg x) @@ -34044,7 +34272,7 @@ func rewriteValueS390X_OpSignExt8to32(v *Value) bool { return true } } -func rewriteValueS390X_OpSignExt8to64(v *Value) bool { +func rewriteValueS390X_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 x) // cond: // result: (MOVBreg x) @@ -34055,7 +34283,7 @@ func rewriteValueS390X_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValueS390X_OpSlicemask(v *Value) bool { +func rewriteValueS390X_OpSlicemask_0(v *Value) bool { b := v.Block _ = b // match: (Slicemask x) @@ -34072,7 +34300,7 @@ func rewriteValueS390X_OpSlicemask(v *Value) bool { return true } } -func rewriteValueS390X_OpSqrt(v *Value) bool { +func rewriteValueS390X_OpSqrt_0(v *Value) bool { // match: (Sqrt x) // cond: // result: (FSQRT x) @@ -34083,7 +34311,7 @@ func rewriteValueS390X_OpSqrt(v *Value) bool { return true } } -func rewriteValueS390X_OpStaticCall(v *Value) bool { +func rewriteValueS390X_OpStaticCall_0(v *Value) bool { // match: (StaticCall [argwid] {target} mem) // cond: // result: (CALLstatic [argwid] {target} mem) @@ -34098,7 +34326,7 @@ func rewriteValueS390X_OpStaticCall(v *Value) bool { return true } } -func rewriteValueS390X_OpStore(v *Value) bool { +func rewriteValueS390X_OpStore_0(v *Value) bool { // match: (Store {t} ptr val mem) // cond: t.(Type).Size() == 8 && is64BitFloat(val.Type) // result: (FMOVDstore ptr val mem) @@ -34203,7 +34431,7 @@ func rewriteValueS390X_OpStore(v *Value) bool { } return false } -func rewriteValueS390X_OpSub16(v *Value) bool { +func rewriteValueS390X_OpSub16_0(v *Value) bool { // match: (Sub16 x y) // cond: // result: (SUBW x y) @@ -34216,7 +34444,7 @@ func rewriteValueS390X_OpSub16(v *Value) bool { return true } } -func rewriteValueS390X_OpSub32(v *Value) bool { +func rewriteValueS390X_OpSub32_0(v *Value) bool { // match: (Sub32 x y) // cond: // result: (SUBW x y) @@ -34229,7 +34457,7 @@ func rewriteValueS390X_OpSub32(v *Value) bool { return true } } -func rewriteValueS390X_OpSub32F(v *Value) bool { +func rewriteValueS390X_OpSub32F_0(v *Value) bool { // match: (Sub32F x y) // cond: // result: (FSUBS x y) @@ -34242,7 +34470,7 @@ func rewriteValueS390X_OpSub32F(v *Value) bool { return true } } -func rewriteValueS390X_OpSub64(v *Value) bool { +func rewriteValueS390X_OpSub64_0(v *Value) bool { // match: (Sub64 x y) // cond: // result: (SUB x y) @@ -34255,7 +34483,7 @@ func rewriteValueS390X_OpSub64(v *Value) bool { return true } } -func rewriteValueS390X_OpSub64F(v *Value) bool { +func rewriteValueS390X_OpSub64F_0(v *Value) bool { // match: (Sub64F x y) // cond: // result: (FSUB x y) @@ -34268,7 +34496,7 @@ func rewriteValueS390X_OpSub64F(v *Value) bool { return true } } -func rewriteValueS390X_OpSub8(v *Value) bool { +func rewriteValueS390X_OpSub8_0(v *Value) bool { // match: (Sub8 x y) // cond: // result: (SUBW x y) @@ -34281,7 +34509,7 @@ func rewriteValueS390X_OpSub8(v *Value) bool { return true } } -func rewriteValueS390X_OpSubPtr(v *Value) bool { +func rewriteValueS390X_OpSubPtr_0(v *Value) bool { // match: (SubPtr x y) // cond: // result: (SUB x y) @@ -34294,7 +34522,7 @@ func rewriteValueS390X_OpSubPtr(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc16to8(v *Value) bool { +func rewriteValueS390X_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 x) // cond: // result: x @@ -34306,7 +34534,7 @@ func rewriteValueS390X_OpTrunc16to8(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc32to16(v *Value) bool { +func rewriteValueS390X_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 x) // cond: // result: x @@ -34318,7 +34546,7 @@ func rewriteValueS390X_OpTrunc32to16(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc32to8(v *Value) bool { +func rewriteValueS390X_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 x) // cond: // result: x @@ -34330,7 +34558,7 @@ func rewriteValueS390X_OpTrunc32to8(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc64to16(v *Value) bool { +func rewriteValueS390X_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 x) // cond: // result: x @@ -34342,7 +34570,7 @@ func rewriteValueS390X_OpTrunc64to16(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc64to32(v *Value) bool { +func rewriteValueS390X_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 x) // cond: // result: x @@ -34354,7 +34582,7 @@ func rewriteValueS390X_OpTrunc64to32(v *Value) bool { return true } } -func rewriteValueS390X_OpTrunc64to8(v *Value) bool { +func rewriteValueS390X_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 x) // cond: // result: x @@ -34366,7 +34594,7 @@ func rewriteValueS390X_OpTrunc64to8(v *Value) bool { return true } } -func rewriteValueS390X_OpXor16(v *Value) bool { +func rewriteValueS390X_OpXor16_0(v *Value) bool { // match: (Xor16 x y) // cond: // result: (XORW x y) @@ -34379,7 +34607,7 @@ func rewriteValueS390X_OpXor16(v *Value) bool { return true } } -func rewriteValueS390X_OpXor32(v *Value) bool { +func rewriteValueS390X_OpXor32_0(v *Value) bool { // match: (Xor32 x y) // cond: // result: (XORW x y) @@ -34392,7 +34620,7 @@ func rewriteValueS390X_OpXor32(v *Value) bool { return true } } -func rewriteValueS390X_OpXor64(v *Value) bool { +func rewriteValueS390X_OpXor64_0(v *Value) bool { // match: (Xor64 x y) // cond: // result: (XOR x y) @@ -34405,7 +34633,7 @@ func rewriteValueS390X_OpXor64(v *Value) bool { return true } } -func rewriteValueS390X_OpXor8(v *Value) bool { +func rewriteValueS390X_OpXor8_0(v *Value) bool { // match: (Xor8 x y) // cond: // result: (XORW x y) @@ -34418,7 +34646,7 @@ func rewriteValueS390X_OpXor8(v *Value) bool { return true } } -func rewriteValueS390X_OpZero(v *Value) bool { +func rewriteValueS390X_OpZero_0(v *Value) bool { b := v.Block _ = b // match: (Zero [0] _ mem) @@ -34586,6 +34814,11 @@ func rewriteValueS390X_OpZero(v *Value) bool { 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 [(s/256)*256]) mem) @@ -34608,7 +34841,7 @@ func rewriteValueS390X_OpZero(v *Value) bool { } return false } -func rewriteValueS390X_OpZeroExt16to32(v *Value) bool { +func rewriteValueS390X_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 x) // cond: // result: (MOVHZreg x) @@ -34619,7 +34852,7 @@ func rewriteValueS390X_OpZeroExt16to32(v *Value) bool { return true } } -func rewriteValueS390X_OpZeroExt16to64(v *Value) bool { +func rewriteValueS390X_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 x) // cond: // result: (MOVHZreg x) @@ -34630,7 +34863,7 @@ func rewriteValueS390X_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValueS390X_OpZeroExt32to64(v *Value) bool { +func rewriteValueS390X_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 x) // cond: // result: (MOVWZreg x) @@ -34641,7 +34874,7 @@ func rewriteValueS390X_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValueS390X_OpZeroExt8to16(v *Value) bool { +func rewriteValueS390X_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 x) // cond: // result: (MOVBZreg x) @@ -34652,7 +34885,7 @@ func rewriteValueS390X_OpZeroExt8to16(v *Value) bool { return true } } -func rewriteValueS390X_OpZeroExt8to32(v *Value) bool { +func rewriteValueS390X_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 x) // cond: // result: (MOVBZreg x) @@ -34663,7 +34896,7 @@ func rewriteValueS390X_OpZeroExt8to32(v *Value) bool { return true } } -func rewriteValueS390X_OpZeroExt8to64(v *Value) bool { +func rewriteValueS390X_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 x) // cond: // result: (MOVBZreg x) diff --git a/src/cmd/compile/internal/ssa/rewritedec.go b/src/cmd/compile/internal/ssa/rewritedec.go index 305fc7bd72..7040abbec0 100644 --- a/src/cmd/compile/internal/ssa/rewritedec.go +++ b/src/cmd/compile/internal/ssa/rewritedec.go @@ -14,31 +14,31 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValuedec(v *Value) bool { switch v.Op { case OpComplexImag: - return rewriteValuedec_OpComplexImag(v) + return rewriteValuedec_OpComplexImag_0(v) case OpComplexReal: - return rewriteValuedec_OpComplexReal(v) + return rewriteValuedec_OpComplexReal_0(v) case OpIData: - return rewriteValuedec_OpIData(v) + return rewriteValuedec_OpIData_0(v) case OpITab: - return rewriteValuedec_OpITab(v) + return rewriteValuedec_OpITab_0(v) case OpLoad: - return rewriteValuedec_OpLoad(v) + return rewriteValuedec_OpLoad_0(v) case OpSliceCap: - return rewriteValuedec_OpSliceCap(v) + return rewriteValuedec_OpSliceCap_0(v) case OpSliceLen: - return rewriteValuedec_OpSliceLen(v) + return rewriteValuedec_OpSliceLen_0(v) case OpSlicePtr: - return rewriteValuedec_OpSlicePtr(v) + return rewriteValuedec_OpSlicePtr_0(v) case OpStore: - return rewriteValuedec_OpStore(v) + return rewriteValuedec_OpStore_0(v) case OpStringLen: - return rewriteValuedec_OpStringLen(v) + return rewriteValuedec_OpStringLen_0(v) case OpStringPtr: - return rewriteValuedec_OpStringPtr(v) + return rewriteValuedec_OpStringPtr_0(v) } return false } -func rewriteValuedec_OpComplexImag(v *Value) bool { +func rewriteValuedec_OpComplexImag_0(v *Value) bool { // match: (ComplexImag (ComplexMake _ imag)) // cond: // result: imag @@ -55,7 +55,7 @@ func rewriteValuedec_OpComplexImag(v *Value) bool { } return false } -func rewriteValuedec_OpComplexReal(v *Value) bool { +func rewriteValuedec_OpComplexReal_0(v *Value) bool { // match: (ComplexReal (ComplexMake real _)) // cond: // result: real @@ -72,7 +72,7 @@ func rewriteValuedec_OpComplexReal(v *Value) bool { } return false } -func rewriteValuedec_OpIData(v *Value) bool { +func rewriteValuedec_OpIData_0(v *Value) bool { // match: (IData (IMake _ data)) // cond: // result: data @@ -89,7 +89,7 @@ func rewriteValuedec_OpIData(v *Value) bool { } return false } -func rewriteValuedec_OpITab(v *Value) bool { +func rewriteValuedec_OpITab_0(v *Value) bool { b := v.Block _ = b // match: (ITab (IMake itab _)) @@ -108,7 +108,7 @@ func rewriteValuedec_OpITab(v *Value) bool { } return false } -func rewriteValuedec_OpLoad(v *Value) bool { +func rewriteValuedec_OpLoad_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -244,7 +244,7 @@ func rewriteValuedec_OpLoad(v *Value) bool { } return false } -func rewriteValuedec_OpSliceCap(v *Value) bool { +func rewriteValuedec_OpSliceCap_0(v *Value) bool { // match: (SliceCap (SliceMake _ _ cap)) // cond: // result: cap @@ -261,7 +261,7 @@ func rewriteValuedec_OpSliceCap(v *Value) bool { } return false } -func rewriteValuedec_OpSliceLen(v *Value) bool { +func rewriteValuedec_OpSliceLen_0(v *Value) bool { // match: (SliceLen (SliceMake _ len _)) // cond: // result: len @@ -278,7 +278,7 @@ func rewriteValuedec_OpSliceLen(v *Value) bool { } return false } -func rewriteValuedec_OpSlicePtr(v *Value) bool { +func rewriteValuedec_OpSlicePtr_0(v *Value) bool { // match: (SlicePtr (SliceMake ptr _ _)) // cond: // result: ptr @@ -295,7 +295,7 @@ func rewriteValuedec_OpSlicePtr(v *Value) bool { } return false } -func rewriteValuedec_OpStore(v *Value) bool { +func rewriteValuedec_OpStore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -456,7 +456,7 @@ func rewriteValuedec_OpStore(v *Value) bool { } return false } -func rewriteValuedec_OpStringLen(v *Value) bool { +func rewriteValuedec_OpStringLen_0(v *Value) bool { // match: (StringLen (StringMake _ len)) // cond: // result: len @@ -473,7 +473,7 @@ func rewriteValuedec_OpStringLen(v *Value) bool { } return false } -func rewriteValuedec_OpStringPtr(v *Value) bool { +func rewriteValuedec_OpStringPtr_0(v *Value) bool { // match: (StringPtr (StringMake ptr _)) // cond: // result: ptr diff --git a/src/cmd/compile/internal/ssa/rewritedec64.go b/src/cmd/compile/internal/ssa/rewritedec64.go index 4b9b3783e2..0fe0d2197e 100644 --- a/src/cmd/compile/internal/ssa/rewritedec64.go +++ b/src/cmd/compile/internal/ssa/rewritedec64.go @@ -14,123 +14,123 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValuedec64(v *Value) bool { switch v.Op { case OpAdd64: - return rewriteValuedec64_OpAdd64(v) + return rewriteValuedec64_OpAdd64_0(v) case OpAnd64: - return rewriteValuedec64_OpAnd64(v) + return rewriteValuedec64_OpAnd64_0(v) case OpArg: - return rewriteValuedec64_OpArg(v) + return rewriteValuedec64_OpArg_0(v) case OpBitLen64: - return rewriteValuedec64_OpBitLen64(v) + return rewriteValuedec64_OpBitLen64_0(v) case OpBswap64: - return rewriteValuedec64_OpBswap64(v) + return rewriteValuedec64_OpBswap64_0(v) case OpCom64: - return rewriteValuedec64_OpCom64(v) + return rewriteValuedec64_OpCom64_0(v) case OpConst64: - return rewriteValuedec64_OpConst64(v) + return rewriteValuedec64_OpConst64_0(v) case OpCtz64: - return rewriteValuedec64_OpCtz64(v) + return rewriteValuedec64_OpCtz64_0(v) case OpEq64: - return rewriteValuedec64_OpEq64(v) + return rewriteValuedec64_OpEq64_0(v) case OpGeq64: - return rewriteValuedec64_OpGeq64(v) + return rewriteValuedec64_OpGeq64_0(v) case OpGeq64U: - return rewriteValuedec64_OpGeq64U(v) + return rewriteValuedec64_OpGeq64U_0(v) case OpGreater64: - return rewriteValuedec64_OpGreater64(v) + return rewriteValuedec64_OpGreater64_0(v) case OpGreater64U: - return rewriteValuedec64_OpGreater64U(v) + return rewriteValuedec64_OpGreater64U_0(v) case OpInt64Hi: - return rewriteValuedec64_OpInt64Hi(v) + return rewriteValuedec64_OpInt64Hi_0(v) case OpInt64Lo: - return rewriteValuedec64_OpInt64Lo(v) + return rewriteValuedec64_OpInt64Lo_0(v) case OpLeq64: - return rewriteValuedec64_OpLeq64(v) + return rewriteValuedec64_OpLeq64_0(v) case OpLeq64U: - return rewriteValuedec64_OpLeq64U(v) + return rewriteValuedec64_OpLeq64U_0(v) case OpLess64: - return rewriteValuedec64_OpLess64(v) + return rewriteValuedec64_OpLess64_0(v) case OpLess64U: - return rewriteValuedec64_OpLess64U(v) + return rewriteValuedec64_OpLess64U_0(v) case OpLoad: - return rewriteValuedec64_OpLoad(v) + return rewriteValuedec64_OpLoad_0(v) case OpLsh16x64: - return rewriteValuedec64_OpLsh16x64(v) + return rewriteValuedec64_OpLsh16x64_0(v) case OpLsh32x64: - return rewriteValuedec64_OpLsh32x64(v) + return rewriteValuedec64_OpLsh32x64_0(v) case OpLsh64x16: - return rewriteValuedec64_OpLsh64x16(v) + return rewriteValuedec64_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValuedec64_OpLsh64x32(v) + return rewriteValuedec64_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValuedec64_OpLsh64x64(v) + return rewriteValuedec64_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValuedec64_OpLsh64x8(v) + return rewriteValuedec64_OpLsh64x8_0(v) case OpLsh8x64: - return rewriteValuedec64_OpLsh8x64(v) + return rewriteValuedec64_OpLsh8x64_0(v) case OpMul64: - return rewriteValuedec64_OpMul64(v) + return rewriteValuedec64_OpMul64_0(v) case OpNeg64: - return rewriteValuedec64_OpNeg64(v) + return rewriteValuedec64_OpNeg64_0(v) case OpNeq64: - return rewriteValuedec64_OpNeq64(v) + return rewriteValuedec64_OpNeq64_0(v) case OpOr64: - return rewriteValuedec64_OpOr64(v) + return rewriteValuedec64_OpOr64_0(v) case OpRsh16Ux64: - return rewriteValuedec64_OpRsh16Ux64(v) + return rewriteValuedec64_OpRsh16Ux64_0(v) case OpRsh16x64: - return rewriteValuedec64_OpRsh16x64(v) + return rewriteValuedec64_OpRsh16x64_0(v) case OpRsh32Ux64: - return rewriteValuedec64_OpRsh32Ux64(v) + return rewriteValuedec64_OpRsh32Ux64_0(v) case OpRsh32x64: - return rewriteValuedec64_OpRsh32x64(v) + return rewriteValuedec64_OpRsh32x64_0(v) case OpRsh64Ux16: - return rewriteValuedec64_OpRsh64Ux16(v) + return rewriteValuedec64_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValuedec64_OpRsh64Ux32(v) + return rewriteValuedec64_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValuedec64_OpRsh64Ux64(v) + return rewriteValuedec64_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValuedec64_OpRsh64Ux8(v) + return rewriteValuedec64_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValuedec64_OpRsh64x16(v) + return rewriteValuedec64_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValuedec64_OpRsh64x32(v) + return rewriteValuedec64_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValuedec64_OpRsh64x64(v) + return rewriteValuedec64_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValuedec64_OpRsh64x8(v) + return rewriteValuedec64_OpRsh64x8_0(v) case OpRsh8Ux64: - return rewriteValuedec64_OpRsh8Ux64(v) + return rewriteValuedec64_OpRsh8Ux64_0(v) case OpRsh8x64: - return rewriteValuedec64_OpRsh8x64(v) + return rewriteValuedec64_OpRsh8x64_0(v) case OpSignExt16to64: - return rewriteValuedec64_OpSignExt16to64(v) + return rewriteValuedec64_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValuedec64_OpSignExt32to64(v) + return rewriteValuedec64_OpSignExt32to64_0(v) case OpSignExt8to64: - return rewriteValuedec64_OpSignExt8to64(v) + return rewriteValuedec64_OpSignExt8to64_0(v) case OpStore: - return rewriteValuedec64_OpStore(v) + return rewriteValuedec64_OpStore_0(v) case OpSub64: - return rewriteValuedec64_OpSub64(v) + return rewriteValuedec64_OpSub64_0(v) case OpTrunc64to16: - return rewriteValuedec64_OpTrunc64to16(v) + return rewriteValuedec64_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValuedec64_OpTrunc64to32(v) + return rewriteValuedec64_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValuedec64_OpTrunc64to8(v) + return rewriteValuedec64_OpTrunc64to8_0(v) case OpXor64: - return rewriteValuedec64_OpXor64(v) + return rewriteValuedec64_OpXor64_0(v) case OpZeroExt16to64: - return rewriteValuedec64_OpZeroExt16to64(v) + return rewriteValuedec64_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValuedec64_OpZeroExt32to64(v) + return rewriteValuedec64_OpZeroExt32to64_0(v) case OpZeroExt8to64: - return rewriteValuedec64_OpZeroExt8to64(v) + return rewriteValuedec64_OpZeroExt8to64_0(v) } return false } -func rewriteValuedec64_OpAdd64(v *Value) bool { +func rewriteValuedec64_OpAdd64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -173,7 +173,7 @@ func rewriteValuedec64_OpAdd64(v *Value) bool { return true } } -func rewriteValuedec64_OpAnd64(v *Value) bool { +func rewriteValuedec64_OpAnd64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -204,7 +204,7 @@ func rewriteValuedec64_OpAnd64(v *Value) bool { return true } } -func rewriteValuedec64_OpArg(v *Value) bool { +func rewriteValuedec64_OpArg_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -293,7 +293,7 @@ func rewriteValuedec64_OpArg(v *Value) bool { } return false } -func rewriteValuedec64_OpBitLen64(v *Value) bool { +func rewriteValuedec64_OpBitLen64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -325,7 +325,7 @@ func rewriteValuedec64_OpBitLen64(v *Value) bool { return true } } -func rewriteValuedec64_OpBswap64(v *Value) bool { +func rewriteValuedec64_OpBswap64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -349,7 +349,7 @@ func rewriteValuedec64_OpBswap64(v *Value) bool { return true } } -func rewriteValuedec64_OpCom64(v *Value) bool { +func rewriteValuedec64_OpCom64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -373,7 +373,7 @@ func rewriteValuedec64_OpCom64(v *Value) bool { return true } } -func rewriteValuedec64_OpConst64(v *Value) bool { +func rewriteValuedec64_OpConst64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -416,7 +416,7 @@ func rewriteValuedec64_OpConst64(v *Value) bool { } return false } -func rewriteValuedec64_OpCtz64(v *Value) bool { +func rewriteValuedec64_OpCtz64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -450,7 +450,7 @@ func rewriteValuedec64_OpCtz64(v *Value) bool { return true } } -func rewriteValuedec64_OpEq64(v *Value) bool { +func rewriteValuedec64_OpEq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -481,7 +481,7 @@ func rewriteValuedec64_OpEq64(v *Value) bool { return true } } -func rewriteValuedec64_OpGeq64(v *Value) bool { +func rewriteValuedec64_OpGeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -522,7 +522,7 @@ func rewriteValuedec64_OpGeq64(v *Value) bool { return true } } -func rewriteValuedec64_OpGeq64U(v *Value) bool { +func rewriteValuedec64_OpGeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -563,7 +563,7 @@ func rewriteValuedec64_OpGeq64U(v *Value) bool { return true } } -func rewriteValuedec64_OpGreater64(v *Value) bool { +func rewriteValuedec64_OpGreater64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -604,7 +604,7 @@ func rewriteValuedec64_OpGreater64(v *Value) bool { return true } } -func rewriteValuedec64_OpGreater64U(v *Value) bool { +func rewriteValuedec64_OpGreater64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -645,7 +645,7 @@ func rewriteValuedec64_OpGreater64U(v *Value) bool { return true } } -func rewriteValuedec64_OpInt64Hi(v *Value) bool { +func rewriteValuedec64_OpInt64Hi_0(v *Value) bool { // match: (Int64Hi (Int64Make hi _)) // cond: // result: hi @@ -662,7 +662,7 @@ func rewriteValuedec64_OpInt64Hi(v *Value) bool { } return false } -func rewriteValuedec64_OpInt64Lo(v *Value) bool { +func rewriteValuedec64_OpInt64Lo_0(v *Value) bool { // match: (Int64Lo (Int64Make _ lo)) // cond: // result: lo @@ -679,7 +679,7 @@ func rewriteValuedec64_OpInt64Lo(v *Value) bool { } return false } -func rewriteValuedec64_OpLeq64(v *Value) bool { +func rewriteValuedec64_OpLeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -720,7 +720,7 @@ func rewriteValuedec64_OpLeq64(v *Value) bool { return true } } -func rewriteValuedec64_OpLeq64U(v *Value) bool { +func rewriteValuedec64_OpLeq64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -761,7 +761,7 @@ func rewriteValuedec64_OpLeq64U(v *Value) bool { return true } } -func rewriteValuedec64_OpLess64(v *Value) bool { +func rewriteValuedec64_OpLess64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -802,7 +802,7 @@ func rewriteValuedec64_OpLess64(v *Value) bool { return true } } -func rewriteValuedec64_OpLess64U(v *Value) bool { +func rewriteValuedec64_OpLess64U_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -843,7 +843,7 @@ func rewriteValuedec64_OpLess64U(v *Value) bool { return true } } -func rewriteValuedec64_OpLoad(v *Value) bool { +func rewriteValuedec64_OpLoad_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -948,7 +948,7 @@ func rewriteValuedec64_OpLoad(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh16x64(v *Value) bool { +func rewriteValuedec64_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1021,7 +1021,7 @@ func rewriteValuedec64_OpLsh16x64(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh32x64(v *Value) bool { +func rewriteValuedec64_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1094,7 +1094,7 @@ func rewriteValuedec64_OpLsh32x64(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh64x16(v *Value) bool { +func rewriteValuedec64_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1145,7 +1145,7 @@ func rewriteValuedec64_OpLsh64x16(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh64x32(v *Value) bool { +func rewriteValuedec64_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1196,7 +1196,7 @@ func rewriteValuedec64_OpLsh64x32(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh64x64(v *Value) bool { +func rewriteValuedec64_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1269,7 +1269,7 @@ func rewriteValuedec64_OpLsh64x64(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh64x8(v *Value) bool { +func rewriteValuedec64_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1320,7 +1320,7 @@ func rewriteValuedec64_OpLsh64x8(v *Value) bool { } return false } -func rewriteValuedec64_OpLsh8x64(v *Value) bool { +func rewriteValuedec64_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1393,7 +1393,7 @@ func rewriteValuedec64_OpLsh8x64(v *Value) bool { } return false } -func rewriteValuedec64_OpMul64(v *Value) bool { +func rewriteValuedec64_OpMul64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1448,7 +1448,7 @@ func rewriteValuedec64_OpMul64(v *Value) bool { return true } } -func rewriteValuedec64_OpNeg64(v *Value) bool { +func rewriteValuedec64_OpNeg64_0(v *Value) bool { b := v.Block _ = b // match: (Neg64 x) @@ -1465,7 +1465,7 @@ func rewriteValuedec64_OpNeg64(v *Value) bool { return true } } -func rewriteValuedec64_OpNeq64(v *Value) bool { +func rewriteValuedec64_OpNeq64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1496,7 +1496,7 @@ func rewriteValuedec64_OpNeq64(v *Value) bool { return true } } -func rewriteValuedec64_OpOr64(v *Value) bool { +func rewriteValuedec64_OpOr64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1527,7 +1527,7 @@ func rewriteValuedec64_OpOr64(v *Value) bool { return true } } -func rewriteValuedec64_OpRsh16Ux64(v *Value) bool { +func rewriteValuedec64_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1600,7 +1600,7 @@ func rewriteValuedec64_OpRsh16Ux64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh16x64(v *Value) bool { +func rewriteValuedec64_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1676,7 +1676,7 @@ func rewriteValuedec64_OpRsh16x64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh32Ux64(v *Value) bool { +func rewriteValuedec64_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1749,7 +1749,7 @@ func rewriteValuedec64_OpRsh32Ux64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh32x64(v *Value) bool { +func rewriteValuedec64_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1823,7 +1823,7 @@ func rewriteValuedec64_OpRsh32x64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64Ux16(v *Value) bool { +func rewriteValuedec64_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1874,7 +1874,7 @@ func rewriteValuedec64_OpRsh64Ux16(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64Ux32(v *Value) bool { +func rewriteValuedec64_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1925,7 +1925,7 @@ func rewriteValuedec64_OpRsh64Ux32(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64Ux64(v *Value) bool { +func rewriteValuedec64_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -1998,7 +1998,7 @@ func rewriteValuedec64_OpRsh64Ux64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64Ux8(v *Value) bool { +func rewriteValuedec64_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2049,7 +2049,7 @@ func rewriteValuedec64_OpRsh64Ux8(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64x16(v *Value) bool { +func rewriteValuedec64_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2112,7 +2112,7 @@ func rewriteValuedec64_OpRsh64x16(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64x32(v *Value) bool { +func rewriteValuedec64_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2173,7 +2173,7 @@ func rewriteValuedec64_OpRsh64x32(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64x64(v *Value) bool { +func rewriteValuedec64_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2256,7 +2256,7 @@ func rewriteValuedec64_OpRsh64x64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh64x8(v *Value) bool { +func rewriteValuedec64_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2319,7 +2319,7 @@ func rewriteValuedec64_OpRsh64x8(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh8Ux64(v *Value) bool { +func rewriteValuedec64_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2392,7 +2392,7 @@ func rewriteValuedec64_OpRsh8Ux64(v *Value) bool { } return false } -func rewriteValuedec64_OpRsh8x64(v *Value) bool { +func rewriteValuedec64_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2468,7 +2468,7 @@ func rewriteValuedec64_OpRsh8x64(v *Value) bool { } return false } -func rewriteValuedec64_OpSignExt16to64(v *Value) bool { +func rewriteValuedec64_OpSignExt16to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2485,7 +2485,7 @@ func rewriteValuedec64_OpSignExt16to64(v *Value) bool { return true } } -func rewriteValuedec64_OpSignExt32to64(v *Value) bool { +func rewriteValuedec64_OpSignExt32to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2503,7 +2503,7 @@ func rewriteValuedec64_OpSignExt32to64(v *Value) bool { return true } } -func rewriteValuedec64_OpSignExt8to64(v *Value) bool { +func rewriteValuedec64_OpSignExt8to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2520,7 +2520,7 @@ func rewriteValuedec64_OpSignExt8to64(v *Value) bool { return true } } -func rewriteValuedec64_OpStore(v *Value) bool { +func rewriteValuedec64_OpStore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -2589,7 +2589,7 @@ func rewriteValuedec64_OpStore(v *Value) bool { } return false } -func rewriteValuedec64_OpSub64(v *Value) bool { +func rewriteValuedec64_OpSub64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2632,7 +2632,7 @@ func rewriteValuedec64_OpSub64(v *Value) bool { return true } } -func rewriteValuedec64_OpTrunc64to16(v *Value) bool { +func rewriteValuedec64_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 (Int64Make _ lo)) // cond: // result: (Trunc32to16 lo) @@ -2648,7 +2648,7 @@ func rewriteValuedec64_OpTrunc64to16(v *Value) bool { } return false } -func rewriteValuedec64_OpTrunc64to32(v *Value) bool { +func rewriteValuedec64_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 (Int64Make _ lo)) // cond: // result: lo @@ -2665,7 +2665,7 @@ func rewriteValuedec64_OpTrunc64to32(v *Value) bool { } return false } -func rewriteValuedec64_OpTrunc64to8(v *Value) bool { +func rewriteValuedec64_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 (Int64Make _ lo)) // cond: // result: (Trunc32to8 lo) @@ -2681,7 +2681,7 @@ func rewriteValuedec64_OpTrunc64to8(v *Value) bool { } return false } -func rewriteValuedec64_OpXor64(v *Value) bool { +func rewriteValuedec64_OpXor64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2712,7 +2712,7 @@ func rewriteValuedec64_OpXor64(v *Value) bool { return true } } -func rewriteValuedec64_OpZeroExt16to64(v *Value) bool { +func rewriteValuedec64_OpZeroExt16to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2729,7 +2729,7 @@ func rewriteValuedec64_OpZeroExt16to64(v *Value) bool { return true } } -func rewriteValuedec64_OpZeroExt32to64(v *Value) bool { +func rewriteValuedec64_OpZeroExt32to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -2747,7 +2747,7 @@ func rewriteValuedec64_OpZeroExt32to64(v *Value) bool { return true } } -func rewriteValuedec64_OpZeroExt8to64(v *Value) bool { +func rewriteValuedec64_OpZeroExt8to64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types diff --git a/src/cmd/compile/internal/ssa/rewritegeneric.go b/src/cmd/compile/internal/ssa/rewritegeneric.go index 5bd4cac590..70ce0d2621 100644 --- a/src/cmd/compile/internal/ssa/rewritegeneric.go +++ b/src/cmd/compile/internal/ssa/rewritegeneric.go @@ -14,417 +14,417 @@ var _ = objabi.GOROOT // in case not otherwise used func rewriteValuegeneric(v *Value) bool { switch v.Op { case OpAdd16: - return rewriteValuegeneric_OpAdd16(v) + return rewriteValuegeneric_OpAdd16_0(v) || rewriteValuegeneric_OpAdd16_10(v) || rewriteValuegeneric_OpAdd16_20(v) case OpAdd32: - return rewriteValuegeneric_OpAdd32(v) + return rewriteValuegeneric_OpAdd32_0(v) || rewriteValuegeneric_OpAdd32_10(v) || rewriteValuegeneric_OpAdd32_20(v) case OpAdd32F: - return rewriteValuegeneric_OpAdd32F(v) + return rewriteValuegeneric_OpAdd32F_0(v) case OpAdd64: - return rewriteValuegeneric_OpAdd64(v) + return rewriteValuegeneric_OpAdd64_0(v) || rewriteValuegeneric_OpAdd64_10(v) || rewriteValuegeneric_OpAdd64_20(v) case OpAdd64F: - return rewriteValuegeneric_OpAdd64F(v) + return rewriteValuegeneric_OpAdd64F_0(v) case OpAdd8: - return rewriteValuegeneric_OpAdd8(v) + return rewriteValuegeneric_OpAdd8_0(v) || rewriteValuegeneric_OpAdd8_10(v) || rewriteValuegeneric_OpAdd8_20(v) case OpAddPtr: - return rewriteValuegeneric_OpAddPtr(v) + return rewriteValuegeneric_OpAddPtr_0(v) case OpAnd16: - return rewriteValuegeneric_OpAnd16(v) + return rewriteValuegeneric_OpAnd16_0(v) || rewriteValuegeneric_OpAnd16_10(v) case OpAnd32: - return rewriteValuegeneric_OpAnd32(v) + return rewriteValuegeneric_OpAnd32_0(v) || rewriteValuegeneric_OpAnd32_10(v) case OpAnd64: - return rewriteValuegeneric_OpAnd64(v) + return rewriteValuegeneric_OpAnd64_0(v) || rewriteValuegeneric_OpAnd64_10(v) || rewriteValuegeneric_OpAnd64_20(v) case OpAnd8: - return rewriteValuegeneric_OpAnd8(v) + return rewriteValuegeneric_OpAnd8_0(v) || rewriteValuegeneric_OpAnd8_10(v) case OpArg: - return rewriteValuegeneric_OpArg(v) + return rewriteValuegeneric_OpArg_0(v) || rewriteValuegeneric_OpArg_10(v) case OpArraySelect: - return rewriteValuegeneric_OpArraySelect(v) + return rewriteValuegeneric_OpArraySelect_0(v) case OpCom16: - return rewriteValuegeneric_OpCom16(v) + return rewriteValuegeneric_OpCom16_0(v) case OpCom32: - return rewriteValuegeneric_OpCom32(v) + return rewriteValuegeneric_OpCom32_0(v) case OpCom64: - return rewriteValuegeneric_OpCom64(v) + return rewriteValuegeneric_OpCom64_0(v) case OpCom8: - return rewriteValuegeneric_OpCom8(v) + return rewriteValuegeneric_OpCom8_0(v) case OpConstInterface: - return rewriteValuegeneric_OpConstInterface(v) + return rewriteValuegeneric_OpConstInterface_0(v) case OpConstSlice: - return rewriteValuegeneric_OpConstSlice(v) + return rewriteValuegeneric_OpConstSlice_0(v) case OpConstString: - return rewriteValuegeneric_OpConstString(v) + return rewriteValuegeneric_OpConstString_0(v) case OpConvert: - return rewriteValuegeneric_OpConvert(v) + return rewriteValuegeneric_OpConvert_0(v) case OpCvt32Fto64F: - return rewriteValuegeneric_OpCvt32Fto64F(v) + return rewriteValuegeneric_OpCvt32Fto64F_0(v) case OpCvt64Fto32F: - return rewriteValuegeneric_OpCvt64Fto32F(v) + return rewriteValuegeneric_OpCvt64Fto32F_0(v) case OpDiv16: - return rewriteValuegeneric_OpDiv16(v) + return rewriteValuegeneric_OpDiv16_0(v) case OpDiv16u: - return rewriteValuegeneric_OpDiv16u(v) + return rewriteValuegeneric_OpDiv16u_0(v) case OpDiv32: - return rewriteValuegeneric_OpDiv32(v) + return rewriteValuegeneric_OpDiv32_0(v) case OpDiv32F: - return rewriteValuegeneric_OpDiv32F(v) + return rewriteValuegeneric_OpDiv32F_0(v) case OpDiv32u: - return rewriteValuegeneric_OpDiv32u(v) + return rewriteValuegeneric_OpDiv32u_0(v) case OpDiv64: - return rewriteValuegeneric_OpDiv64(v) + return rewriteValuegeneric_OpDiv64_0(v) case OpDiv64F: - return rewriteValuegeneric_OpDiv64F(v) + return rewriteValuegeneric_OpDiv64F_0(v) case OpDiv64u: - return rewriteValuegeneric_OpDiv64u(v) + return rewriteValuegeneric_OpDiv64u_0(v) case OpDiv8: - return rewriteValuegeneric_OpDiv8(v) + return rewriteValuegeneric_OpDiv8_0(v) case OpDiv8u: - return rewriteValuegeneric_OpDiv8u(v) + return rewriteValuegeneric_OpDiv8u_0(v) case OpEq16: - return rewriteValuegeneric_OpEq16(v) + return rewriteValuegeneric_OpEq16_0(v) case OpEq32: - return rewriteValuegeneric_OpEq32(v) + return rewriteValuegeneric_OpEq32_0(v) case OpEq64: - return rewriteValuegeneric_OpEq64(v) + return rewriteValuegeneric_OpEq64_0(v) case OpEq8: - return rewriteValuegeneric_OpEq8(v) + return rewriteValuegeneric_OpEq8_0(v) case OpEqB: - return rewriteValuegeneric_OpEqB(v) + return rewriteValuegeneric_OpEqB_0(v) case OpEqInter: - return rewriteValuegeneric_OpEqInter(v) + return rewriteValuegeneric_OpEqInter_0(v) case OpEqPtr: - return rewriteValuegeneric_OpEqPtr(v) + return rewriteValuegeneric_OpEqPtr_0(v) case OpEqSlice: - return rewriteValuegeneric_OpEqSlice(v) + return rewriteValuegeneric_OpEqSlice_0(v) case OpGeq16: - return rewriteValuegeneric_OpGeq16(v) + return rewriteValuegeneric_OpGeq16_0(v) case OpGeq16U: - return rewriteValuegeneric_OpGeq16U(v) + return rewriteValuegeneric_OpGeq16U_0(v) case OpGeq32: - return rewriteValuegeneric_OpGeq32(v) + return rewriteValuegeneric_OpGeq32_0(v) case OpGeq32U: - return rewriteValuegeneric_OpGeq32U(v) + return rewriteValuegeneric_OpGeq32U_0(v) case OpGeq64: - return rewriteValuegeneric_OpGeq64(v) + return rewriteValuegeneric_OpGeq64_0(v) case OpGeq64U: - return rewriteValuegeneric_OpGeq64U(v) + return rewriteValuegeneric_OpGeq64U_0(v) case OpGeq8: - return rewriteValuegeneric_OpGeq8(v) + return rewriteValuegeneric_OpGeq8_0(v) case OpGeq8U: - return rewriteValuegeneric_OpGeq8U(v) + return rewriteValuegeneric_OpGeq8U_0(v) case OpGreater16: - return rewriteValuegeneric_OpGreater16(v) + return rewriteValuegeneric_OpGreater16_0(v) case OpGreater16U: - return rewriteValuegeneric_OpGreater16U(v) + return rewriteValuegeneric_OpGreater16U_0(v) case OpGreater32: - return rewriteValuegeneric_OpGreater32(v) + return rewriteValuegeneric_OpGreater32_0(v) case OpGreater32U: - return rewriteValuegeneric_OpGreater32U(v) + return rewriteValuegeneric_OpGreater32U_0(v) case OpGreater64: - return rewriteValuegeneric_OpGreater64(v) + return rewriteValuegeneric_OpGreater64_0(v) case OpGreater64U: - return rewriteValuegeneric_OpGreater64U(v) + return rewriteValuegeneric_OpGreater64U_0(v) case OpGreater8: - return rewriteValuegeneric_OpGreater8(v) + return rewriteValuegeneric_OpGreater8_0(v) case OpGreater8U: - return rewriteValuegeneric_OpGreater8U(v) + return rewriteValuegeneric_OpGreater8U_0(v) case OpIMake: - return rewriteValuegeneric_OpIMake(v) + return rewriteValuegeneric_OpIMake_0(v) case OpInterCall: - return rewriteValuegeneric_OpInterCall(v) + return rewriteValuegeneric_OpInterCall_0(v) case OpIsInBounds: - return rewriteValuegeneric_OpIsInBounds(v) + return rewriteValuegeneric_OpIsInBounds_0(v) || rewriteValuegeneric_OpIsInBounds_10(v) || rewriteValuegeneric_OpIsInBounds_20(v) case OpIsNonNil: - return rewriteValuegeneric_OpIsNonNil(v) + return rewriteValuegeneric_OpIsNonNil_0(v) case OpIsSliceInBounds: - return rewriteValuegeneric_OpIsSliceInBounds(v) + return rewriteValuegeneric_OpIsSliceInBounds_0(v) case OpLeq16: - return rewriteValuegeneric_OpLeq16(v) + return rewriteValuegeneric_OpLeq16_0(v) case OpLeq16U: - return rewriteValuegeneric_OpLeq16U(v) + return rewriteValuegeneric_OpLeq16U_0(v) case OpLeq32: - return rewriteValuegeneric_OpLeq32(v) + return rewriteValuegeneric_OpLeq32_0(v) case OpLeq32U: - return rewriteValuegeneric_OpLeq32U(v) + return rewriteValuegeneric_OpLeq32U_0(v) case OpLeq64: - return rewriteValuegeneric_OpLeq64(v) + return rewriteValuegeneric_OpLeq64_0(v) case OpLeq64U: - return rewriteValuegeneric_OpLeq64U(v) + return rewriteValuegeneric_OpLeq64U_0(v) case OpLeq8: - return rewriteValuegeneric_OpLeq8(v) + return rewriteValuegeneric_OpLeq8_0(v) case OpLeq8U: - return rewriteValuegeneric_OpLeq8U(v) + return rewriteValuegeneric_OpLeq8U_0(v) case OpLess16: - return rewriteValuegeneric_OpLess16(v) + return rewriteValuegeneric_OpLess16_0(v) case OpLess16U: - return rewriteValuegeneric_OpLess16U(v) + return rewriteValuegeneric_OpLess16U_0(v) case OpLess32: - return rewriteValuegeneric_OpLess32(v) + return rewriteValuegeneric_OpLess32_0(v) case OpLess32U: - return rewriteValuegeneric_OpLess32U(v) + return rewriteValuegeneric_OpLess32U_0(v) case OpLess64: - return rewriteValuegeneric_OpLess64(v) + return rewriteValuegeneric_OpLess64_0(v) case OpLess64U: - return rewriteValuegeneric_OpLess64U(v) + return rewriteValuegeneric_OpLess64U_0(v) case OpLess8: - return rewriteValuegeneric_OpLess8(v) + return rewriteValuegeneric_OpLess8_0(v) case OpLess8U: - return rewriteValuegeneric_OpLess8U(v) + return rewriteValuegeneric_OpLess8U_0(v) case OpLoad: - return rewriteValuegeneric_OpLoad(v) + return rewriteValuegeneric_OpLoad_0(v) case OpLsh16x16: - return rewriteValuegeneric_OpLsh16x16(v) + return rewriteValuegeneric_OpLsh16x16_0(v) case OpLsh16x32: - return rewriteValuegeneric_OpLsh16x32(v) + return rewriteValuegeneric_OpLsh16x32_0(v) case OpLsh16x64: - return rewriteValuegeneric_OpLsh16x64(v) + return rewriteValuegeneric_OpLsh16x64_0(v) case OpLsh16x8: - return rewriteValuegeneric_OpLsh16x8(v) + return rewriteValuegeneric_OpLsh16x8_0(v) case OpLsh32x16: - return rewriteValuegeneric_OpLsh32x16(v) + return rewriteValuegeneric_OpLsh32x16_0(v) case OpLsh32x32: - return rewriteValuegeneric_OpLsh32x32(v) + return rewriteValuegeneric_OpLsh32x32_0(v) case OpLsh32x64: - return rewriteValuegeneric_OpLsh32x64(v) + return rewriteValuegeneric_OpLsh32x64_0(v) case OpLsh32x8: - return rewriteValuegeneric_OpLsh32x8(v) + return rewriteValuegeneric_OpLsh32x8_0(v) case OpLsh64x16: - return rewriteValuegeneric_OpLsh64x16(v) + return rewriteValuegeneric_OpLsh64x16_0(v) case OpLsh64x32: - return rewriteValuegeneric_OpLsh64x32(v) + return rewriteValuegeneric_OpLsh64x32_0(v) case OpLsh64x64: - return rewriteValuegeneric_OpLsh64x64(v) + return rewriteValuegeneric_OpLsh64x64_0(v) case OpLsh64x8: - return rewriteValuegeneric_OpLsh64x8(v) + return rewriteValuegeneric_OpLsh64x8_0(v) case OpLsh8x16: - return rewriteValuegeneric_OpLsh8x16(v) + return rewriteValuegeneric_OpLsh8x16_0(v) case OpLsh8x32: - return rewriteValuegeneric_OpLsh8x32(v) + return rewriteValuegeneric_OpLsh8x32_0(v) case OpLsh8x64: - return rewriteValuegeneric_OpLsh8x64(v) + return rewriteValuegeneric_OpLsh8x64_0(v) case OpLsh8x8: - return rewriteValuegeneric_OpLsh8x8(v) + return rewriteValuegeneric_OpLsh8x8_0(v) case OpMod16: - return rewriteValuegeneric_OpMod16(v) + return rewriteValuegeneric_OpMod16_0(v) case OpMod16u: - return rewriteValuegeneric_OpMod16u(v) + return rewriteValuegeneric_OpMod16u_0(v) case OpMod32: - return rewriteValuegeneric_OpMod32(v) + return rewriteValuegeneric_OpMod32_0(v) case OpMod32u: - return rewriteValuegeneric_OpMod32u(v) + return rewriteValuegeneric_OpMod32u_0(v) case OpMod64: - return rewriteValuegeneric_OpMod64(v) + return rewriteValuegeneric_OpMod64_0(v) case OpMod64u: - return rewriteValuegeneric_OpMod64u(v) + return rewriteValuegeneric_OpMod64u_0(v) case OpMod8: - return rewriteValuegeneric_OpMod8(v) + return rewriteValuegeneric_OpMod8_0(v) case OpMod8u: - return rewriteValuegeneric_OpMod8u(v) + return rewriteValuegeneric_OpMod8u_0(v) case OpMul16: - return rewriteValuegeneric_OpMul16(v) + return rewriteValuegeneric_OpMul16_0(v) || rewriteValuegeneric_OpMul16_10(v) case OpMul32: - return rewriteValuegeneric_OpMul32(v) + return rewriteValuegeneric_OpMul32_0(v) || rewriteValuegeneric_OpMul32_10(v) case OpMul32F: - return rewriteValuegeneric_OpMul32F(v) + return rewriteValuegeneric_OpMul32F_0(v) case OpMul64: - return rewriteValuegeneric_OpMul64(v) + return rewriteValuegeneric_OpMul64_0(v) || rewriteValuegeneric_OpMul64_10(v) case OpMul64F: - return rewriteValuegeneric_OpMul64F(v) + return rewriteValuegeneric_OpMul64F_0(v) case OpMul8: - return rewriteValuegeneric_OpMul8(v) + return rewriteValuegeneric_OpMul8_0(v) || rewriteValuegeneric_OpMul8_10(v) case OpNeg16: - return rewriteValuegeneric_OpNeg16(v) + return rewriteValuegeneric_OpNeg16_0(v) case OpNeg32: - return rewriteValuegeneric_OpNeg32(v) + return rewriteValuegeneric_OpNeg32_0(v) case OpNeg32F: - return rewriteValuegeneric_OpNeg32F(v) + return rewriteValuegeneric_OpNeg32F_0(v) case OpNeg64: - return rewriteValuegeneric_OpNeg64(v) + return rewriteValuegeneric_OpNeg64_0(v) case OpNeg64F: - return rewriteValuegeneric_OpNeg64F(v) + return rewriteValuegeneric_OpNeg64F_0(v) case OpNeg8: - return rewriteValuegeneric_OpNeg8(v) + return rewriteValuegeneric_OpNeg8_0(v) case OpNeq16: - return rewriteValuegeneric_OpNeq16(v) + return rewriteValuegeneric_OpNeq16_0(v) case OpNeq32: - return rewriteValuegeneric_OpNeq32(v) + return rewriteValuegeneric_OpNeq32_0(v) case OpNeq64: - return rewriteValuegeneric_OpNeq64(v) + return rewriteValuegeneric_OpNeq64_0(v) case OpNeq8: - return rewriteValuegeneric_OpNeq8(v) + return rewriteValuegeneric_OpNeq8_0(v) case OpNeqB: - return rewriteValuegeneric_OpNeqB(v) + return rewriteValuegeneric_OpNeqB_0(v) case OpNeqInter: - return rewriteValuegeneric_OpNeqInter(v) + return rewriteValuegeneric_OpNeqInter_0(v) case OpNeqPtr: - return rewriteValuegeneric_OpNeqPtr(v) + return rewriteValuegeneric_OpNeqPtr_0(v) case OpNeqSlice: - return rewriteValuegeneric_OpNeqSlice(v) + return rewriteValuegeneric_OpNeqSlice_0(v) case OpNilCheck: - return rewriteValuegeneric_OpNilCheck(v) + return rewriteValuegeneric_OpNilCheck_0(v) case OpNot: - return rewriteValuegeneric_OpNot(v) + return rewriteValuegeneric_OpNot_0(v) || rewriteValuegeneric_OpNot_10(v) || rewriteValuegeneric_OpNot_20(v) || rewriteValuegeneric_OpNot_30(v) || rewriteValuegeneric_OpNot_40(v) case OpOffPtr: - return rewriteValuegeneric_OpOffPtr(v) + return rewriteValuegeneric_OpOffPtr_0(v) case OpOr16: - return rewriteValuegeneric_OpOr16(v) + return rewriteValuegeneric_OpOr16_0(v) || rewriteValuegeneric_OpOr16_10(v) case OpOr32: - return rewriteValuegeneric_OpOr32(v) + return rewriteValuegeneric_OpOr32_0(v) || rewriteValuegeneric_OpOr32_10(v) case OpOr64: - return rewriteValuegeneric_OpOr64(v) + return rewriteValuegeneric_OpOr64_0(v) || rewriteValuegeneric_OpOr64_10(v) case OpOr8: - return rewriteValuegeneric_OpOr8(v) + return rewriteValuegeneric_OpOr8_0(v) || rewriteValuegeneric_OpOr8_10(v) case OpPhi: - return rewriteValuegeneric_OpPhi(v) + return rewriteValuegeneric_OpPhi_0(v) case OpPtrIndex: - return rewriteValuegeneric_OpPtrIndex(v) + return rewriteValuegeneric_OpPtrIndex_0(v) case OpRound32F: - return rewriteValuegeneric_OpRound32F(v) + return rewriteValuegeneric_OpRound32F_0(v) case OpRound64F: - return rewriteValuegeneric_OpRound64F(v) + return rewriteValuegeneric_OpRound64F_0(v) case OpRsh16Ux16: - return rewriteValuegeneric_OpRsh16Ux16(v) + return rewriteValuegeneric_OpRsh16Ux16_0(v) case OpRsh16Ux32: - return rewriteValuegeneric_OpRsh16Ux32(v) + return rewriteValuegeneric_OpRsh16Ux32_0(v) case OpRsh16Ux64: - return rewriteValuegeneric_OpRsh16Ux64(v) + return rewriteValuegeneric_OpRsh16Ux64_0(v) case OpRsh16Ux8: - return rewriteValuegeneric_OpRsh16Ux8(v) + return rewriteValuegeneric_OpRsh16Ux8_0(v) case OpRsh16x16: - return rewriteValuegeneric_OpRsh16x16(v) + return rewriteValuegeneric_OpRsh16x16_0(v) case OpRsh16x32: - return rewriteValuegeneric_OpRsh16x32(v) + return rewriteValuegeneric_OpRsh16x32_0(v) case OpRsh16x64: - return rewriteValuegeneric_OpRsh16x64(v) + return rewriteValuegeneric_OpRsh16x64_0(v) case OpRsh16x8: - return rewriteValuegeneric_OpRsh16x8(v) + return rewriteValuegeneric_OpRsh16x8_0(v) case OpRsh32Ux16: - return rewriteValuegeneric_OpRsh32Ux16(v) + return rewriteValuegeneric_OpRsh32Ux16_0(v) case OpRsh32Ux32: - return rewriteValuegeneric_OpRsh32Ux32(v) + return rewriteValuegeneric_OpRsh32Ux32_0(v) case OpRsh32Ux64: - return rewriteValuegeneric_OpRsh32Ux64(v) + return rewriteValuegeneric_OpRsh32Ux64_0(v) case OpRsh32Ux8: - return rewriteValuegeneric_OpRsh32Ux8(v) + return rewriteValuegeneric_OpRsh32Ux8_0(v) case OpRsh32x16: - return rewriteValuegeneric_OpRsh32x16(v) + return rewriteValuegeneric_OpRsh32x16_0(v) case OpRsh32x32: - return rewriteValuegeneric_OpRsh32x32(v) + return rewriteValuegeneric_OpRsh32x32_0(v) case OpRsh32x64: - return rewriteValuegeneric_OpRsh32x64(v) + return rewriteValuegeneric_OpRsh32x64_0(v) case OpRsh32x8: - return rewriteValuegeneric_OpRsh32x8(v) + return rewriteValuegeneric_OpRsh32x8_0(v) case OpRsh64Ux16: - return rewriteValuegeneric_OpRsh64Ux16(v) + return rewriteValuegeneric_OpRsh64Ux16_0(v) case OpRsh64Ux32: - return rewriteValuegeneric_OpRsh64Ux32(v) + return rewriteValuegeneric_OpRsh64Ux32_0(v) case OpRsh64Ux64: - return rewriteValuegeneric_OpRsh64Ux64(v) + return rewriteValuegeneric_OpRsh64Ux64_0(v) case OpRsh64Ux8: - return rewriteValuegeneric_OpRsh64Ux8(v) + return rewriteValuegeneric_OpRsh64Ux8_0(v) case OpRsh64x16: - return rewriteValuegeneric_OpRsh64x16(v) + return rewriteValuegeneric_OpRsh64x16_0(v) case OpRsh64x32: - return rewriteValuegeneric_OpRsh64x32(v) + return rewriteValuegeneric_OpRsh64x32_0(v) case OpRsh64x64: - return rewriteValuegeneric_OpRsh64x64(v) + return rewriteValuegeneric_OpRsh64x64_0(v) case OpRsh64x8: - return rewriteValuegeneric_OpRsh64x8(v) + return rewriteValuegeneric_OpRsh64x8_0(v) case OpRsh8Ux16: - return rewriteValuegeneric_OpRsh8Ux16(v) + return rewriteValuegeneric_OpRsh8Ux16_0(v) case OpRsh8Ux32: - return rewriteValuegeneric_OpRsh8Ux32(v) + return rewriteValuegeneric_OpRsh8Ux32_0(v) case OpRsh8Ux64: - return rewriteValuegeneric_OpRsh8Ux64(v) + return rewriteValuegeneric_OpRsh8Ux64_0(v) case OpRsh8Ux8: - return rewriteValuegeneric_OpRsh8Ux8(v) + return rewriteValuegeneric_OpRsh8Ux8_0(v) case OpRsh8x16: - return rewriteValuegeneric_OpRsh8x16(v) + return rewriteValuegeneric_OpRsh8x16_0(v) case OpRsh8x32: - return rewriteValuegeneric_OpRsh8x32(v) + return rewriteValuegeneric_OpRsh8x32_0(v) case OpRsh8x64: - return rewriteValuegeneric_OpRsh8x64(v) + return rewriteValuegeneric_OpRsh8x64_0(v) case OpRsh8x8: - return rewriteValuegeneric_OpRsh8x8(v) + return rewriteValuegeneric_OpRsh8x8_0(v) case OpSignExt16to32: - return rewriteValuegeneric_OpSignExt16to32(v) + return rewriteValuegeneric_OpSignExt16to32_0(v) case OpSignExt16to64: - return rewriteValuegeneric_OpSignExt16to64(v) + return rewriteValuegeneric_OpSignExt16to64_0(v) case OpSignExt32to64: - return rewriteValuegeneric_OpSignExt32to64(v) + return rewriteValuegeneric_OpSignExt32to64_0(v) case OpSignExt8to16: - return rewriteValuegeneric_OpSignExt8to16(v) + return rewriteValuegeneric_OpSignExt8to16_0(v) case OpSignExt8to32: - return rewriteValuegeneric_OpSignExt8to32(v) + return rewriteValuegeneric_OpSignExt8to32_0(v) case OpSignExt8to64: - return rewriteValuegeneric_OpSignExt8to64(v) + return rewriteValuegeneric_OpSignExt8to64_0(v) case OpSliceCap: - return rewriteValuegeneric_OpSliceCap(v) + return rewriteValuegeneric_OpSliceCap_0(v) case OpSliceLen: - return rewriteValuegeneric_OpSliceLen(v) + return rewriteValuegeneric_OpSliceLen_0(v) case OpSlicePtr: - return rewriteValuegeneric_OpSlicePtr(v) + return rewriteValuegeneric_OpSlicePtr_0(v) case OpSlicemask: - return rewriteValuegeneric_OpSlicemask(v) + return rewriteValuegeneric_OpSlicemask_0(v) case OpSqrt: - return rewriteValuegeneric_OpSqrt(v) + return rewriteValuegeneric_OpSqrt_0(v) case OpStore: - return rewriteValuegeneric_OpStore(v) + return rewriteValuegeneric_OpStore_0(v) || rewriteValuegeneric_OpStore_10(v) case OpStringLen: - return rewriteValuegeneric_OpStringLen(v) + return rewriteValuegeneric_OpStringLen_0(v) case OpStringPtr: - return rewriteValuegeneric_OpStringPtr(v) + return rewriteValuegeneric_OpStringPtr_0(v) case OpStructSelect: - return rewriteValuegeneric_OpStructSelect(v) + return rewriteValuegeneric_OpStructSelect_0(v) || rewriteValuegeneric_OpStructSelect_10(v) case OpSub16: - return rewriteValuegeneric_OpSub16(v) + return rewriteValuegeneric_OpSub16_0(v) || rewriteValuegeneric_OpSub16_10(v) case OpSub32: - return rewriteValuegeneric_OpSub32(v) + return rewriteValuegeneric_OpSub32_0(v) || rewriteValuegeneric_OpSub32_10(v) case OpSub32F: - return rewriteValuegeneric_OpSub32F(v) + return rewriteValuegeneric_OpSub32F_0(v) case OpSub64: - return rewriteValuegeneric_OpSub64(v) + return rewriteValuegeneric_OpSub64_0(v) || rewriteValuegeneric_OpSub64_10(v) case OpSub64F: - return rewriteValuegeneric_OpSub64F(v) + return rewriteValuegeneric_OpSub64F_0(v) case OpSub8: - return rewriteValuegeneric_OpSub8(v) + return rewriteValuegeneric_OpSub8_0(v) || rewriteValuegeneric_OpSub8_10(v) case OpTrunc16to8: - return rewriteValuegeneric_OpTrunc16to8(v) + return rewriteValuegeneric_OpTrunc16to8_0(v) case OpTrunc32to16: - return rewriteValuegeneric_OpTrunc32to16(v) + return rewriteValuegeneric_OpTrunc32to16_0(v) case OpTrunc32to8: - return rewriteValuegeneric_OpTrunc32to8(v) + return rewriteValuegeneric_OpTrunc32to8_0(v) case OpTrunc64to16: - return rewriteValuegeneric_OpTrunc64to16(v) + return rewriteValuegeneric_OpTrunc64to16_0(v) case OpTrunc64to32: - return rewriteValuegeneric_OpTrunc64to32(v) + return rewriteValuegeneric_OpTrunc64to32_0(v) case OpTrunc64to8: - return rewriteValuegeneric_OpTrunc64to8(v) + return rewriteValuegeneric_OpTrunc64to8_0(v) case OpXor16: - return rewriteValuegeneric_OpXor16(v) + return rewriteValuegeneric_OpXor16_0(v) || rewriteValuegeneric_OpXor16_10(v) case OpXor32: - return rewriteValuegeneric_OpXor32(v) + return rewriteValuegeneric_OpXor32_0(v) || rewriteValuegeneric_OpXor32_10(v) case OpXor64: - return rewriteValuegeneric_OpXor64(v) + return rewriteValuegeneric_OpXor64_0(v) || rewriteValuegeneric_OpXor64_10(v) case OpXor8: - return rewriteValuegeneric_OpXor8(v) + return rewriteValuegeneric_OpXor8_0(v) || rewriteValuegeneric_OpXor8_10(v) case OpZero: - return rewriteValuegeneric_OpZero(v) + return rewriteValuegeneric_OpZero_0(v) case OpZeroExt16to32: - return rewriteValuegeneric_OpZeroExt16to32(v) + return rewriteValuegeneric_OpZeroExt16to32_0(v) case OpZeroExt16to64: - return rewriteValuegeneric_OpZeroExt16to64(v) + return rewriteValuegeneric_OpZeroExt16to64_0(v) case OpZeroExt32to64: - return rewriteValuegeneric_OpZeroExt32to64(v) + return rewriteValuegeneric_OpZeroExt32to64_0(v) case OpZeroExt8to16: - return rewriteValuegeneric_OpZeroExt8to16(v) + return rewriteValuegeneric_OpZeroExt8to16_0(v) case OpZeroExt8to32: - return rewriteValuegeneric_OpZeroExt8to32(v) + return rewriteValuegeneric_OpZeroExt8to32_0(v) case OpZeroExt8to64: - return rewriteValuegeneric_OpZeroExt8to64(v) + return rewriteValuegeneric_OpZeroExt8to64_0(v) } return false } -func rewriteValuegeneric_OpAdd16(v *Value) bool { +func rewriteValuegeneric_OpAdd16_0(v *Value) bool { b := v.Block _ = b // match: (Add16 (Const16 [c]) (Const16 [d])) @@ -641,6 +641,11 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpAdd16_10(v *Value) bool { + b := v.Block + _ = b // match: (Add16 (Sub16 i:(Const16 ) z) x) // cond: (z.Op != OpConst16 && x.Op != OpConst16) // result: (Add16 i (Sub16 x z)) @@ -909,6 +914,11 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpAdd16_20(v *Value) bool { + b := v.Block + _ = b // match: (Add16 (Add16 (Const16 [d]) x) (Const16 [c])) // cond: // result: (Add16 (Const16 [int64(int16(c+d))]) x) @@ -1091,7 +1101,7 @@ func rewriteValuegeneric_OpAdd16(v *Value) bool { } return false } -func rewriteValuegeneric_OpAdd32(v *Value) bool { +func rewriteValuegeneric_OpAdd32_0(v *Value) bool { b := v.Block _ = b // match: (Add32 (Const32 [c]) (Const32 [d])) @@ -1308,6 +1318,11 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpAdd32_10(v *Value) bool { + b := v.Block + _ = b // match: (Add32 (Sub32 i:(Const32 ) z) x) // cond: (z.Op != OpConst32 && x.Op != OpConst32) // result: (Add32 i (Sub32 x z)) @@ -1576,6 +1591,11 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpAdd32_20(v *Value) bool { + b := v.Block + _ = b // match: (Add32 (Add32 (Const32 [d]) x) (Const32 [c])) // cond: // result: (Add32 (Const32 [int64(int32(c+d))]) x) @@ -1758,7 +1778,7 @@ func rewriteValuegeneric_OpAdd32(v *Value) bool { } return false } -func rewriteValuegeneric_OpAdd32F(v *Value) bool { +func rewriteValuegeneric_OpAdd32F_0(v *Value) bool { // match: (Add32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) + i2f32(d)))]) @@ -1831,7 +1851,7 @@ func rewriteValuegeneric_OpAdd32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpAdd64(v *Value) bool { +func rewriteValuegeneric_OpAdd64_0(v *Value) bool { b := v.Block _ = b // match: (Add64 (Const64 [c]) (Const64 [d])) @@ -2048,6 +2068,11 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpAdd64_10(v *Value) bool { + b := v.Block + _ = b // match: (Add64 (Sub64 i:(Const64 ) z) x) // cond: (z.Op != OpConst64 && x.Op != OpConst64) // result: (Add64 i (Sub64 x z)) @@ -2316,6 +2341,11 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpAdd64_20(v *Value) bool { + b := v.Block + _ = b // match: (Add64 (Add64 (Const64 [d]) x) (Const64 [c])) // cond: // result: (Add64 (Const64 [c+d]) x) @@ -2498,7 +2528,7 @@ func rewriteValuegeneric_OpAdd64(v *Value) bool { } return false } -func rewriteValuegeneric_OpAdd64F(v *Value) bool { +func rewriteValuegeneric_OpAdd64F_0(v *Value) bool { // match: (Add64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) + i2f(d))]) @@ -2571,7 +2601,7 @@ func rewriteValuegeneric_OpAdd64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpAdd8(v *Value) bool { +func rewriteValuegeneric_OpAdd8_0(v *Value) bool { b := v.Block _ = b // match: (Add8 (Const8 [c]) (Const8 [d])) @@ -2788,6 +2818,11 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpAdd8_10(v *Value) bool { + b := v.Block + _ = b // match: (Add8 (Sub8 i:(Const8 ) z) x) // cond: (z.Op != OpConst8 && x.Op != OpConst8) // result: (Add8 i (Sub8 x z)) @@ -3056,6 +3091,11 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpAdd8_20(v *Value) bool { + b := v.Block + _ = b // match: (Add8 (Add8 (Const8 [d]) x) (Const8 [c])) // cond: // result: (Add8 (Const8 [int64(int8(c+d))]) x) @@ -3238,7 +3278,7 @@ func rewriteValuegeneric_OpAdd8(v *Value) bool { } return false } -func rewriteValuegeneric_OpAddPtr(v *Value) bool { +func rewriteValuegeneric_OpAddPtr_0(v *Value) bool { // match: (AddPtr x (Const64 [c])) // cond: // result: (OffPtr x [c]) @@ -3275,9 +3315,7 @@ func rewriteValuegeneric_OpAddPtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpAnd16(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAnd16_0(v *Value) bool { // match: (And16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [int64(int16(c&d))]) @@ -3445,6 +3483,11 @@ func rewriteValuegeneric_OpAnd16(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpAnd16_10(v *Value) bool { + b := v.Block + _ = b // match: (And16 (And16 y x) x) // cond: // result: (And16 x y) @@ -3689,9 +3732,7 @@ func rewriteValuegeneric_OpAnd16(v *Value) bool { } return false } -func rewriteValuegeneric_OpAnd32(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAnd32_0(v *Value) bool { // match: (And32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [int64(int32(c&d))]) @@ -3859,6 +3900,11 @@ func rewriteValuegeneric_OpAnd32(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpAnd32_10(v *Value) bool { + b := v.Block + _ = b // match: (And32 (And32 y x) x) // cond: // result: (And32 x y) @@ -4103,9 +4149,7 @@ func rewriteValuegeneric_OpAnd32(v *Value) bool { } return false } -func rewriteValuegeneric_OpAnd64(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAnd64_0(v *Value) bool { // match: (And64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c&d]) @@ -4273,6 +4317,11 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpAnd64_10(v *Value) bool { + b := v.Block + _ = b // match: (And64 (And64 y x) x) // cond: // result: (And64 x y) @@ -4529,6 +4578,11 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpAnd64_20(v *Value) bool { + b := v.Block + _ = b // match: (And64 (Const64 [c]) (And64 x (Const64 [d]))) // cond: // result: (And64 (Const64 [c&d]) x) @@ -4621,9 +4675,7 @@ func rewriteValuegeneric_OpAnd64(v *Value) bool { } return false } -func rewriteValuegeneric_OpAnd8(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpAnd8_0(v *Value) bool { // match: (And8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [int64(int8(c&d))]) @@ -4791,6 +4843,11 @@ func rewriteValuegeneric_OpAnd8(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpAnd8_10(v *Value) bool { + b := v.Block + _ = b // match: (And8 (And8 y x) x) // cond: // result: (And8 x y) @@ -5035,7 +5092,7 @@ func rewriteValuegeneric_OpAnd8(v *Value) bool { } return false } -func rewriteValuegeneric_OpArg(v *Value) bool { +func rewriteValuegeneric_OpArg_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5251,6 +5308,13 @@ func rewriteValuegeneric_OpArg(v *Value) bool { v.AddArg(v3) return true } + return false +} +func rewriteValuegeneric_OpArg_10(v *Value) bool { + b := v.Block + _ = b + fe := b.Func.fe + _ = fe // match: (Arg ) // cond: t.IsArray() && t.NumElem() == 0 // result: (ArrayMake0) @@ -5281,7 +5345,7 @@ func rewriteValuegeneric_OpArg(v *Value) bool { } return false } -func rewriteValuegeneric_OpArraySelect(v *Value) bool { +func rewriteValuegeneric_OpArraySelect_0(v *Value) bool { // match: (ArraySelect (ArrayMake1 x)) // cond: // result: x @@ -5332,7 +5396,7 @@ func rewriteValuegeneric_OpArraySelect(v *Value) bool { } return false } -func rewriteValuegeneric_OpCom16(v *Value) bool { +func rewriteValuegeneric_OpCom16_0(v *Value) bool { // match: (Com16 (Com16 x)) // cond: // result: x @@ -5349,7 +5413,7 @@ func rewriteValuegeneric_OpCom16(v *Value) bool { } return false } -func rewriteValuegeneric_OpCom32(v *Value) bool { +func rewriteValuegeneric_OpCom32_0(v *Value) bool { // match: (Com32 (Com32 x)) // cond: // result: x @@ -5366,7 +5430,7 @@ func rewriteValuegeneric_OpCom32(v *Value) bool { } return false } -func rewriteValuegeneric_OpCom64(v *Value) bool { +func rewriteValuegeneric_OpCom64_0(v *Value) bool { // match: (Com64 (Com64 x)) // cond: // result: x @@ -5383,7 +5447,7 @@ func rewriteValuegeneric_OpCom64(v *Value) bool { } return false } -func rewriteValuegeneric_OpCom8(v *Value) bool { +func rewriteValuegeneric_OpCom8_0(v *Value) bool { // match: (Com8 (Com8 x)) // cond: // result: x @@ -5400,7 +5464,7 @@ func rewriteValuegeneric_OpCom8(v *Value) bool { } return false } -func rewriteValuegeneric_OpConstInterface(v *Value) bool { +func rewriteValuegeneric_OpConstInterface_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5417,7 +5481,7 @@ func rewriteValuegeneric_OpConstInterface(v *Value) bool { return true } } -func rewriteValuegeneric_OpConstSlice(v *Value) bool { +func rewriteValuegeneric_OpConstSlice_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5462,7 +5526,7 @@ func rewriteValuegeneric_OpConstSlice(v *Value) bool { } return false } -func rewriteValuegeneric_OpConstString(v *Value) bool { +func rewriteValuegeneric_OpConstString_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5543,7 +5607,7 @@ func rewriteValuegeneric_OpConstString(v *Value) bool { } return false } -func rewriteValuegeneric_OpConvert(v *Value) bool { +func rewriteValuegeneric_OpConvert_0(v *Value) bool { // match: (Convert (Add64 (Convert ptr mem) off) mem) // cond: // result: (Add64 ptr off) @@ -5610,7 +5674,7 @@ func rewriteValuegeneric_OpConvert(v *Value) bool { } return false } -func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool { +func rewriteValuegeneric_OpCvt32Fto64F_0(v *Value) bool { // match: (Cvt32Fto64F (Const32F [c])) // cond: // result: (Const64F [c]) @@ -5626,7 +5690,7 @@ func rewriteValuegeneric_OpCvt32Fto64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool { +func rewriteValuegeneric_OpCvt64Fto32F_0(v *Value) bool { // match: (Cvt64Fto32F (Const64F [c])) // cond: // result: (Const32F [f2i(float64(i2f32(c)))]) @@ -5642,7 +5706,7 @@ func rewriteValuegeneric_OpCvt64Fto32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv16(v *Value) bool { +func rewriteValuegeneric_OpDiv16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -5791,7 +5855,7 @@ func rewriteValuegeneric_OpDiv16(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv16u(v *Value) bool { +func rewriteValuegeneric_OpDiv16u_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -5972,7 +6036,7 @@ func rewriteValuegeneric_OpDiv16u(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv32(v *Value) bool { +func rewriteValuegeneric_OpDiv32_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6196,7 +6260,7 @@ func rewriteValuegeneric_OpDiv32(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv32F(v *Value) bool { +func rewriteValuegeneric_OpDiv32F_0(v *Value) bool { b := v.Block _ = b // match: (Div32F (Const32F [c]) (Const32F [d])) @@ -6240,7 +6304,7 @@ func rewriteValuegeneric_OpDiv32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv32u(v *Value) bool { +func rewriteValuegeneric_OpDiv32u_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6478,7 +6542,7 @@ func rewriteValuegeneric_OpDiv32u(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv64(v *Value) bool { +func rewriteValuegeneric_OpDiv64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6661,7 +6725,7 @@ func rewriteValuegeneric_OpDiv64(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv64F(v *Value) bool { +func rewriteValuegeneric_OpDiv64F_0(v *Value) bool { b := v.Block _ = b // match: (Div64F (Const64F [c]) (Const64F [d])) @@ -6705,7 +6769,7 @@ func rewriteValuegeneric_OpDiv64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv64u(v *Value) bool { +func rewriteValuegeneric_OpDiv64u_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -6841,7 +6905,7 @@ func rewriteValuegeneric_OpDiv64u(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv8(v *Value) bool { +func rewriteValuegeneric_OpDiv8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -6990,7 +7054,7 @@ func rewriteValuegeneric_OpDiv8(v *Value) bool { } return false } -func rewriteValuegeneric_OpDiv8u(v *Value) bool { +func rewriteValuegeneric_OpDiv8u_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7067,7 +7131,7 @@ func rewriteValuegeneric_OpDiv8u(v *Value) bool { } return false } -func rewriteValuegeneric_OpEq16(v *Value) bool { +func rewriteValuegeneric_OpEq16_0(v *Value) bool { b := v.Block _ = b // match: (Eq16 x x) @@ -7240,7 +7304,7 @@ func rewriteValuegeneric_OpEq16(v *Value) bool { } return false } -func rewriteValuegeneric_OpEq32(v *Value) bool { +func rewriteValuegeneric_OpEq32_0(v *Value) bool { b := v.Block _ = b // match: (Eq32 x x) @@ -7413,7 +7477,7 @@ func rewriteValuegeneric_OpEq32(v *Value) bool { } return false } -func rewriteValuegeneric_OpEq64(v *Value) bool { +func rewriteValuegeneric_OpEq64_0(v *Value) bool { b := v.Block _ = b // match: (Eq64 x x) @@ -7586,7 +7650,7 @@ func rewriteValuegeneric_OpEq64(v *Value) bool { } return false } -func rewriteValuegeneric_OpEq8(v *Value) bool { +func rewriteValuegeneric_OpEq8_0(v *Value) bool { b := v.Block _ = b // match: (Eq8 x x) @@ -7759,7 +7823,7 @@ func rewriteValuegeneric_OpEq8(v *Value) bool { } return false } -func rewriteValuegeneric_OpEqB(v *Value) bool { +func rewriteValuegeneric_OpEqB_0(v *Value) bool { // match: (EqB (ConstBool [c]) (ConstBool [d])) // cond: // result: (ConstBool [b2i(c == d)]) @@ -7813,7 +7877,7 @@ func rewriteValuegeneric_OpEqB(v *Value) bool { } return false } -func rewriteValuegeneric_OpEqInter(v *Value) bool { +func rewriteValuegeneric_OpEqInter_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7834,7 +7898,7 @@ func rewriteValuegeneric_OpEqInter(v *Value) bool { return true } } -func rewriteValuegeneric_OpEqPtr(v *Value) bool { +func rewriteValuegeneric_OpEqPtr_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7927,7 +7991,7 @@ func rewriteValuegeneric_OpEqPtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpEqSlice(v *Value) bool { +func rewriteValuegeneric_OpEqSlice_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -7948,7 +8012,7 @@ func rewriteValuegeneric_OpEqSlice(v *Value) bool { return true } } -func rewriteValuegeneric_OpGeq16(v *Value) bool { +func rewriteValuegeneric_OpGeq16_0(v *Value) bool { // match: (Geq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -7969,7 +8033,7 @@ func rewriteValuegeneric_OpGeq16(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq16U(v *Value) bool { +func rewriteValuegeneric_OpGeq16U_0(v *Value) bool { // match: (Geq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) >= uint16(d))]) @@ -7990,7 +8054,7 @@ func rewriteValuegeneric_OpGeq16U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq32(v *Value) bool { +func rewriteValuegeneric_OpGeq32_0(v *Value) bool { // match: (Geq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -8011,7 +8075,7 @@ func rewriteValuegeneric_OpGeq32(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq32U(v *Value) bool { +func rewriteValuegeneric_OpGeq32U_0(v *Value) bool { // match: (Geq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) >= uint32(d))]) @@ -8032,7 +8096,7 @@ func rewriteValuegeneric_OpGeq32U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq64(v *Value) bool { +func rewriteValuegeneric_OpGeq64_0(v *Value) bool { // match: (Geq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -8053,7 +8117,7 @@ func rewriteValuegeneric_OpGeq64(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq64U(v *Value) bool { +func rewriteValuegeneric_OpGeq64U_0(v *Value) bool { // match: (Geq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) >= uint64(d))]) @@ -8074,7 +8138,7 @@ func rewriteValuegeneric_OpGeq64U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq8(v *Value) bool { +func rewriteValuegeneric_OpGeq8_0(v *Value) bool { // match: (Geq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c >= d)]) @@ -8095,7 +8159,7 @@ func rewriteValuegeneric_OpGeq8(v *Value) bool { } return false } -func rewriteValuegeneric_OpGeq8U(v *Value) bool { +func rewriteValuegeneric_OpGeq8U_0(v *Value) bool { // match: (Geq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) >= uint8(d))]) @@ -8116,7 +8180,7 @@ func rewriteValuegeneric_OpGeq8U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater16(v *Value) bool { +func rewriteValuegeneric_OpGreater16_0(v *Value) bool { // match: (Greater16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -8137,7 +8201,7 @@ func rewriteValuegeneric_OpGreater16(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater16U(v *Value) bool { +func rewriteValuegeneric_OpGreater16U_0(v *Value) bool { // match: (Greater16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) > uint16(d))]) @@ -8158,7 +8222,7 @@ func rewriteValuegeneric_OpGreater16U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater32(v *Value) bool { +func rewriteValuegeneric_OpGreater32_0(v *Value) bool { // match: (Greater32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -8179,7 +8243,7 @@ func rewriteValuegeneric_OpGreater32(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater32U(v *Value) bool { +func rewriteValuegeneric_OpGreater32U_0(v *Value) bool { // match: (Greater32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) > uint32(d))]) @@ -8200,7 +8264,7 @@ func rewriteValuegeneric_OpGreater32U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater64(v *Value) bool { +func rewriteValuegeneric_OpGreater64_0(v *Value) bool { // match: (Greater64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -8221,7 +8285,7 @@ func rewriteValuegeneric_OpGreater64(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater64U(v *Value) bool { +func rewriteValuegeneric_OpGreater64U_0(v *Value) bool { // match: (Greater64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) > uint64(d))]) @@ -8242,7 +8306,7 @@ func rewriteValuegeneric_OpGreater64U(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater8(v *Value) bool { +func rewriteValuegeneric_OpGreater8_0(v *Value) bool { // match: (Greater8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c > d)]) @@ -8263,7 +8327,7 @@ func rewriteValuegeneric_OpGreater8(v *Value) bool { } return false } -func rewriteValuegeneric_OpGreater8U(v *Value) bool { +func rewriteValuegeneric_OpGreater8U_0(v *Value) bool { // match: (Greater8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) > uint8(d))]) @@ -8284,7 +8348,7 @@ func rewriteValuegeneric_OpGreater8U(v *Value) bool { } return false } -func rewriteValuegeneric_OpIMake(v *Value) bool { +func rewriteValuegeneric_OpIMake_0(v *Value) bool { // match: (IMake typ (StructMake1 val)) // cond: // result: (IMake typ val) @@ -8317,7 +8381,7 @@ func rewriteValuegeneric_OpIMake(v *Value) bool { } return false } -func rewriteValuegeneric_OpInterCall(v *Value) bool { +func rewriteValuegeneric_OpInterCall_0(v *Value) bool { // match: (InterCall [argsize] (Load (OffPtr [off] (ITab (IMake (Addr {itab} (SB)) _))) _) mem) // cond: devirt(v, itab, off) != nil // result: (StaticCall [argsize] {devirt(v, itab, off)} mem) @@ -8361,7 +8425,7 @@ func rewriteValuegeneric_OpInterCall(v *Value) bool { } return false } -func rewriteValuegeneric_OpIsInBounds(v *Value) bool { +func rewriteValuegeneric_OpIsInBounds_0(v *Value) bool { // match: (IsInBounds (ZeroExt8to32 _) (Const32 [c])) // cond: (1 << 8) <= c // result: (ConstBool [1]) @@ -8591,6 +8655,9 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool { v.AuxInt = 1 return true } + return false +} +func rewriteValuegeneric_OpIsInBounds_10(v *Value) bool { // match: (IsInBounds (ZeroExt8to32 (And8 _ (Const8 [c]))) (Const32 [d])) // cond: 0 <= c && c < d // result: (ConstBool [1]) @@ -8869,6 +8936,9 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool { v.AuxInt = 1 return true } + return false +} +func rewriteValuegeneric_OpIsInBounds_20(v *Value) bool { // match: (IsInBounds (And32 _ (Const32 [c])) (Const32 [d])) // cond: 0 <= c && c < d // result: (ConstBool [1]) @@ -9072,7 +9142,7 @@ func rewriteValuegeneric_OpIsInBounds(v *Value) bool { } return false } -func rewriteValuegeneric_OpIsNonNil(v *Value) bool { +func rewriteValuegeneric_OpIsNonNil_0(v *Value) bool { // match: (IsNonNil (ConstNil)) // cond: // result: (ConstBool [0]) @@ -9087,7 +9157,7 @@ func rewriteValuegeneric_OpIsNonNil(v *Value) bool { } return false } -func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool { +func rewriteValuegeneric_OpIsSliceInBounds_0(v *Value) bool { // match: (IsSliceInBounds x x) // cond: // result: (ConstBool [1]) @@ -9288,7 +9358,7 @@ func rewriteValuegeneric_OpIsSliceInBounds(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq16(v *Value) bool { +func rewriteValuegeneric_OpLeq16_0(v *Value) bool { // match: (Leq16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -9309,7 +9379,7 @@ func rewriteValuegeneric_OpLeq16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq16U(v *Value) bool { +func rewriteValuegeneric_OpLeq16U_0(v *Value) bool { // match: (Leq16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) <= uint16(d))]) @@ -9330,7 +9400,7 @@ func rewriteValuegeneric_OpLeq16U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq32(v *Value) bool { +func rewriteValuegeneric_OpLeq32_0(v *Value) bool { // match: (Leq32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -9351,7 +9421,7 @@ func rewriteValuegeneric_OpLeq32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq32U(v *Value) bool { +func rewriteValuegeneric_OpLeq32U_0(v *Value) bool { // match: (Leq32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) <= uint32(d))]) @@ -9372,7 +9442,7 @@ func rewriteValuegeneric_OpLeq32U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq64(v *Value) bool { +func rewriteValuegeneric_OpLeq64_0(v *Value) bool { // match: (Leq64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -9393,7 +9463,7 @@ func rewriteValuegeneric_OpLeq64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq64U(v *Value) bool { +func rewriteValuegeneric_OpLeq64U_0(v *Value) bool { // match: (Leq64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) <= uint64(d))]) @@ -9414,7 +9484,7 @@ func rewriteValuegeneric_OpLeq64U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq8(v *Value) bool { +func rewriteValuegeneric_OpLeq8_0(v *Value) bool { // match: (Leq8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c <= d)]) @@ -9435,7 +9505,7 @@ func rewriteValuegeneric_OpLeq8(v *Value) bool { } return false } -func rewriteValuegeneric_OpLeq8U(v *Value) bool { +func rewriteValuegeneric_OpLeq8U_0(v *Value) bool { // match: (Leq8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) <= uint8(d))]) @@ -9456,7 +9526,7 @@ func rewriteValuegeneric_OpLeq8U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess16(v *Value) bool { +func rewriteValuegeneric_OpLess16_0(v *Value) bool { // match: (Less16 (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -9477,7 +9547,7 @@ func rewriteValuegeneric_OpLess16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess16U(v *Value) bool { +func rewriteValuegeneric_OpLess16U_0(v *Value) bool { // match: (Less16U (Const16 [c]) (Const16 [d])) // cond: // result: (ConstBool [b2i(uint16(c) < uint16(d))]) @@ -9498,7 +9568,7 @@ func rewriteValuegeneric_OpLess16U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess32(v *Value) bool { +func rewriteValuegeneric_OpLess32_0(v *Value) bool { // match: (Less32 (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -9519,7 +9589,7 @@ func rewriteValuegeneric_OpLess32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess32U(v *Value) bool { +func rewriteValuegeneric_OpLess32U_0(v *Value) bool { // match: (Less32U (Const32 [c]) (Const32 [d])) // cond: // result: (ConstBool [b2i(uint32(c) < uint32(d))]) @@ -9540,7 +9610,7 @@ func rewriteValuegeneric_OpLess32U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess64(v *Value) bool { +func rewriteValuegeneric_OpLess64_0(v *Value) bool { // match: (Less64 (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -9561,7 +9631,7 @@ func rewriteValuegeneric_OpLess64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess64U(v *Value) bool { +func rewriteValuegeneric_OpLess64U_0(v *Value) bool { // match: (Less64U (Const64 [c]) (Const64 [d])) // cond: // result: (ConstBool [b2i(uint64(c) < uint64(d))]) @@ -9582,7 +9652,7 @@ func rewriteValuegeneric_OpLess64U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess8(v *Value) bool { +func rewriteValuegeneric_OpLess8_0(v *Value) bool { // match: (Less8 (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(c < d)]) @@ -9603,7 +9673,7 @@ func rewriteValuegeneric_OpLess8(v *Value) bool { } return false } -func rewriteValuegeneric_OpLess8U(v *Value) bool { +func rewriteValuegeneric_OpLess8U_0(v *Value) bool { // match: (Less8U (Const8 [c]) (Const8 [d])) // cond: // result: (ConstBool [b2i(uint8(c) < uint8(d))]) @@ -9624,7 +9694,7 @@ func rewriteValuegeneric_OpLess8U(v *Value) bool { } return false } -func rewriteValuegeneric_OpLoad(v *Value) bool { +func rewriteValuegeneric_OpLoad_0(v *Value) bool { b := v.Block _ = b fe := b.Func.fe @@ -9813,7 +9883,7 @@ func rewriteValuegeneric_OpLoad(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh16x16(v *Value) bool { +func rewriteValuegeneric_OpLsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x16 x (Const16 [c])) @@ -9851,7 +9921,7 @@ func rewriteValuegeneric_OpLsh16x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh16x32(v *Value) bool { +func rewriteValuegeneric_OpLsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x32 x (Const32 [c])) @@ -9889,7 +9959,7 @@ func rewriteValuegeneric_OpLsh16x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh16x64(v *Value) bool { +func rewriteValuegeneric_OpLsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10030,7 +10100,7 @@ func rewriteValuegeneric_OpLsh16x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh16x8(v *Value) bool { +func rewriteValuegeneric_OpLsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh16x8 x (Const8 [c])) @@ -10068,7 +10138,7 @@ func rewriteValuegeneric_OpLsh16x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh32x16(v *Value) bool { +func rewriteValuegeneric_OpLsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x16 x (Const16 [c])) @@ -10106,7 +10176,7 @@ func rewriteValuegeneric_OpLsh32x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh32x32(v *Value) bool { +func rewriteValuegeneric_OpLsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x32 x (Const32 [c])) @@ -10144,7 +10214,7 @@ func rewriteValuegeneric_OpLsh32x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh32x64(v *Value) bool { +func rewriteValuegeneric_OpLsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10285,7 +10355,7 @@ func rewriteValuegeneric_OpLsh32x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh32x8(v *Value) bool { +func rewriteValuegeneric_OpLsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh32x8 x (Const8 [c])) @@ -10323,7 +10393,7 @@ func rewriteValuegeneric_OpLsh32x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh64x16(v *Value) bool { +func rewriteValuegeneric_OpLsh64x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x16 x (Const16 [c])) @@ -10361,7 +10431,7 @@ func rewriteValuegeneric_OpLsh64x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh64x32(v *Value) bool { +func rewriteValuegeneric_OpLsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x32 x (Const32 [c])) @@ -10399,7 +10469,7 @@ func rewriteValuegeneric_OpLsh64x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh64x64(v *Value) bool { +func rewriteValuegeneric_OpLsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10540,7 +10610,7 @@ func rewriteValuegeneric_OpLsh64x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh64x8(v *Value) bool { +func rewriteValuegeneric_OpLsh64x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh64x8 x (Const8 [c])) @@ -10578,7 +10648,7 @@ func rewriteValuegeneric_OpLsh64x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh8x16(v *Value) bool { +func rewriteValuegeneric_OpLsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x16 x (Const16 [c])) @@ -10616,7 +10686,7 @@ func rewriteValuegeneric_OpLsh8x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh8x32(v *Value) bool { +func rewriteValuegeneric_OpLsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x32 x (Const32 [c])) @@ -10654,7 +10724,7 @@ func rewriteValuegeneric_OpLsh8x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh8x64(v *Value) bool { +func rewriteValuegeneric_OpLsh8x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -10795,7 +10865,7 @@ func rewriteValuegeneric_OpLsh8x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpLsh8x8(v *Value) bool { +func rewriteValuegeneric_OpLsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Lsh8x8 x (Const8 [c])) @@ -10833,7 +10903,7 @@ func rewriteValuegeneric_OpLsh8x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod16(v *Value) bool { +func rewriteValuegeneric_OpMod16_0(v *Value) bool { b := v.Block _ = b // match: (Mod16 (Const16 [c]) (Const16 [d])) @@ -10910,7 +10980,7 @@ func rewriteValuegeneric_OpMod16(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod16u(v *Value) bool { +func rewriteValuegeneric_OpMod16u_0(v *Value) bool { b := v.Block _ = b // match: (Mod16u (Const16 [c]) (Const16 [d])) @@ -10986,7 +11056,7 @@ func rewriteValuegeneric_OpMod16u(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod32(v *Value) bool { +func rewriteValuegeneric_OpMod32_0(v *Value) bool { b := v.Block _ = b // match: (Mod32 (Const32 [c]) (Const32 [d])) @@ -11063,7 +11133,7 @@ func rewriteValuegeneric_OpMod32(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod32u(v *Value) bool { +func rewriteValuegeneric_OpMod32u_0(v *Value) bool { b := v.Block _ = b // match: (Mod32u (Const32 [c]) (Const32 [d])) @@ -11139,7 +11209,7 @@ func rewriteValuegeneric_OpMod32u(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod64(v *Value) bool { +func rewriteValuegeneric_OpMod64_0(v *Value) bool { b := v.Block _ = b // match: (Mod64 (Const64 [c]) (Const64 [d])) @@ -11216,7 +11286,7 @@ func rewriteValuegeneric_OpMod64(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod64u(v *Value) bool { +func rewriteValuegeneric_OpMod64u_0(v *Value) bool { b := v.Block _ = b // match: (Mod64u (Const64 [c]) (Const64 [d])) @@ -11292,7 +11362,7 @@ func rewriteValuegeneric_OpMod64u(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod8(v *Value) bool { +func rewriteValuegeneric_OpMod8_0(v *Value) bool { b := v.Block _ = b // match: (Mod8 (Const8 [c]) (Const8 [d])) @@ -11369,7 +11439,7 @@ func rewriteValuegeneric_OpMod8(v *Value) bool { } return false } -func rewriteValuegeneric_OpMod8u(v *Value) bool { +func rewriteValuegeneric_OpMod8u_0(v *Value) bool { b := v.Block _ = b // match: (Mod8u (Const8 [c]) (Const8 [d])) @@ -11445,7 +11515,7 @@ func rewriteValuegeneric_OpMod8u(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul16(v *Value) bool { +func rewriteValuegeneric_OpMul16_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11642,6 +11712,11 @@ func rewriteValuegeneric_OpMul16(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpMul16_10(v *Value) bool { + b := v.Block + _ = b // match: (Mul16 (Const16 [0]) _) // cond: // result: (Const16 [0]) @@ -11794,7 +11869,7 @@ func rewriteValuegeneric_OpMul16(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul32(v *Value) bool { +func rewriteValuegeneric_OpMul32_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -11991,6 +12066,11 @@ func rewriteValuegeneric_OpMul32(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpMul32_10(v *Value) bool { + b := v.Block + _ = b // match: (Mul32 (Const32 [c]) (Add32 (Const32 [d]) x)) // cond: // result: (Add32 (Const32 [int64(int32(c*d))]) (Mul32 (Const32 [c]) x)) @@ -12295,7 +12375,7 @@ func rewriteValuegeneric_OpMul32(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul32F(v *Value) bool { +func rewriteValuegeneric_OpMul32F_0(v *Value) bool { // match: (Mul32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) * i2f32(d)))]) @@ -12434,7 +12514,7 @@ func rewriteValuegeneric_OpMul32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul64(v *Value) bool { +func rewriteValuegeneric_OpMul64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -12631,6 +12711,11 @@ func rewriteValuegeneric_OpMul64(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpMul64_10(v *Value) bool { + b := v.Block + _ = b // match: (Mul64 (Const64 [c]) (Add64 (Const64 [d]) x)) // cond: // result: (Add64 (Const64 [c*d]) (Mul64 (Const64 [c]) x)) @@ -12935,7 +13020,7 @@ func rewriteValuegeneric_OpMul64(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul64F(v *Value) bool { +func rewriteValuegeneric_OpMul64F_0(v *Value) bool { // match: (Mul64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) * i2f(d))]) @@ -13074,7 +13159,7 @@ func rewriteValuegeneric_OpMul64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpMul8(v *Value) bool { +func rewriteValuegeneric_OpMul8_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -13271,6 +13356,11 @@ func rewriteValuegeneric_OpMul8(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpMul8_10(v *Value) bool { + b := v.Block + _ = b // match: (Mul8 (Const8 [0]) _) // cond: // result: (Const8 [0]) @@ -13423,7 +13513,7 @@ func rewriteValuegeneric_OpMul8(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg16(v *Value) bool { +func rewriteValuegeneric_OpNeg16_0(v *Value) bool { // match: (Neg16 (Const16 [c])) // cond: // result: (Const16 [int64(-int16(c))]) @@ -13454,7 +13544,7 @@ func rewriteValuegeneric_OpNeg16(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg32(v *Value) bool { +func rewriteValuegeneric_OpNeg32_0(v *Value) bool { // match: (Neg32 (Const32 [c])) // cond: // result: (Const32 [int64(-int32(c))]) @@ -13485,7 +13575,7 @@ func rewriteValuegeneric_OpNeg32(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg32F(v *Value) bool { +func rewriteValuegeneric_OpNeg32F_0(v *Value) bool { // match: (Neg32F (Const32F [c])) // cond: i2f(c) != 0 // result: (Const32F [f2i(-i2f(c))]) @@ -13504,7 +13594,7 @@ func rewriteValuegeneric_OpNeg32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg64(v *Value) bool { +func rewriteValuegeneric_OpNeg64_0(v *Value) bool { // match: (Neg64 (Const64 [c])) // cond: // result: (Const64 [-c]) @@ -13535,7 +13625,7 @@ func rewriteValuegeneric_OpNeg64(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg64F(v *Value) bool { +func rewriteValuegeneric_OpNeg64F_0(v *Value) bool { // match: (Neg64F (Const64F [c])) // cond: i2f(c) != 0 // result: (Const64F [f2i(-i2f(c))]) @@ -13554,7 +13644,7 @@ func rewriteValuegeneric_OpNeg64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeg8(v *Value) bool { +func rewriteValuegeneric_OpNeg8_0(v *Value) bool { // match: (Neg8 (Const8 [c])) // cond: // result: (Const8 [int64( -int8(c))]) @@ -13585,7 +13675,7 @@ func rewriteValuegeneric_OpNeg8(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeq16(v *Value) bool { +func rewriteValuegeneric_OpNeq16_0(v *Value) bool { b := v.Block _ = b // match: (Neq16 x x) @@ -13758,7 +13848,7 @@ func rewriteValuegeneric_OpNeq16(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeq32(v *Value) bool { +func rewriteValuegeneric_OpNeq32_0(v *Value) bool { b := v.Block _ = b // match: (Neq32 x x) @@ -13931,7 +14021,7 @@ func rewriteValuegeneric_OpNeq32(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeq64(v *Value) bool { +func rewriteValuegeneric_OpNeq64_0(v *Value) bool { b := v.Block _ = b // match: (Neq64 x x) @@ -14104,7 +14194,7 @@ func rewriteValuegeneric_OpNeq64(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeq8(v *Value) bool { +func rewriteValuegeneric_OpNeq8_0(v *Value) bool { b := v.Block _ = b // match: (Neq8 x x) @@ -14277,7 +14367,7 @@ func rewriteValuegeneric_OpNeq8(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeqB(v *Value) bool { +func rewriteValuegeneric_OpNeqB_0(v *Value) bool { // match: (NeqB (ConstBool [c]) (ConstBool [d])) // cond: // result: (ConstBool [b2i(c != d)]) @@ -14331,7 +14421,7 @@ func rewriteValuegeneric_OpNeqB(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeqInter(v *Value) bool { +func rewriteValuegeneric_OpNeqInter_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14352,7 +14442,7 @@ func rewriteValuegeneric_OpNeqInter(v *Value) bool { return true } } -func rewriteValuegeneric_OpNeqPtr(v *Value) bool { +func rewriteValuegeneric_OpNeqPtr_0(v *Value) bool { // match: (NeqPtr p (ConstNil)) // cond: // result: (IsNonNil p) @@ -14381,7 +14471,7 @@ func rewriteValuegeneric_OpNeqPtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpNeqSlice(v *Value) bool { +func rewriteValuegeneric_OpNeqSlice_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -14402,7 +14492,7 @@ func rewriteValuegeneric_OpNeqSlice(v *Value) bool { return true } } -func rewriteValuegeneric_OpNilCheck(v *Value) bool { +func rewriteValuegeneric_OpNilCheck_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -14486,7 +14576,7 @@ func rewriteValuegeneric_OpNilCheck(v *Value) bool { } return false } -func rewriteValuegeneric_OpNot(v *Value) bool { +func rewriteValuegeneric_OpNot_0(v *Value) bool { // match: (Not (Eq64 x y)) // cond: // result: (Neq64 x y) @@ -14637,6 +14727,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpNot_10(v *Value) bool { // match: (Not (Greater64 x y)) // cond: // result: (Leq64 x y) @@ -14787,6 +14880,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpNot_20(v *Value) bool { // match: (Not (Geq16 x y)) // cond: // result: (Less16 x y) @@ -14937,6 +15033,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpNot_30(v *Value) bool { // match: (Not (Less64U x y)) // cond: // result: (Geq64U x y) @@ -15087,6 +15186,9 @@ func rewriteValuegeneric_OpNot(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpNot_40(v *Value) bool { // match: (Not (Leq16U x y)) // cond: // result: (Greater16U x y) @@ -15119,7 +15221,7 @@ func rewriteValuegeneric_OpNot(v *Value) bool { } return false } -func rewriteValuegeneric_OpOffPtr(v *Value) bool { +func rewriteValuegeneric_OpOffPtr_0(v *Value) bool { // match: (OffPtr (OffPtr p [b]) [a]) // cond: // result: (OffPtr p [a+b]) @@ -15154,9 +15256,7 @@ func rewriteValuegeneric_OpOffPtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpOr16(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpOr16_0(v *Value) bool { // match: (Or16 (Const16 [c]) (Const16 [d])) // cond: // result: (Const16 [int64(int16(c|d))]) @@ -15324,6 +15424,11 @@ func rewriteValuegeneric_OpOr16(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpOr16_10(v *Value) bool { + b := v.Block + _ = b // match: (Or16 (Or16 y x) x) // cond: // result: (Or16 x y) @@ -15568,9 +15673,7 @@ func rewriteValuegeneric_OpOr16(v *Value) bool { } return false } -func rewriteValuegeneric_OpOr32(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpOr32_0(v *Value) bool { // match: (Or32 (Const32 [c]) (Const32 [d])) // cond: // result: (Const32 [int64(int32(c|d))]) @@ -15738,6 +15841,11 @@ func rewriteValuegeneric_OpOr32(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpOr32_10(v *Value) bool { + b := v.Block + _ = b // match: (Or32 (Or32 y x) x) // cond: // result: (Or32 x y) @@ -15982,9 +16090,7 @@ func rewriteValuegeneric_OpOr32(v *Value) bool { } return false } -func rewriteValuegeneric_OpOr64(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpOr64_0(v *Value) bool { // match: (Or64 (Const64 [c]) (Const64 [d])) // cond: // result: (Const64 [c|d]) @@ -16152,6 +16258,11 @@ func rewriteValuegeneric_OpOr64(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpOr64_10(v *Value) bool { + b := v.Block + _ = b // match: (Or64 (Or64 y x) x) // cond: // result: (Or64 x y) @@ -16396,9 +16507,7 @@ func rewriteValuegeneric_OpOr64(v *Value) bool { } return false } -func rewriteValuegeneric_OpOr8(v *Value) bool { - b := v.Block - _ = b +func rewriteValuegeneric_OpOr8_0(v *Value) bool { // match: (Or8 (Const8 [c]) (Const8 [d])) // cond: // result: (Const8 [int64(int8(c|d))]) @@ -16566,6 +16675,11 @@ func rewriteValuegeneric_OpOr8(v *Value) bool { v.AddArg(y) return true } + return false +} +func rewriteValuegeneric_OpOr8_10(v *Value) bool { + b := v.Block + _ = b // match: (Or8 (Or8 y x) x) // cond: // result: (Or8 x y) @@ -16810,7 +16924,7 @@ func rewriteValuegeneric_OpOr8(v *Value) bool { } return false } -func rewriteValuegeneric_OpPhi(v *Value) bool { +func rewriteValuegeneric_OpPhi_0(v *Value) bool { // match: (Phi (Const8 [c]) (Const8 [c])) // cond: // result: (Const8 [c]) @@ -16905,7 +17019,7 @@ func rewriteValuegeneric_OpPhi(v *Value) bool { } return false } -func rewriteValuegeneric_OpPtrIndex(v *Value) bool { +func rewriteValuegeneric_OpPtrIndex_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -16954,7 +17068,7 @@ func rewriteValuegeneric_OpPtrIndex(v *Value) bool { } return false } -func rewriteValuegeneric_OpRound32F(v *Value) bool { +func rewriteValuegeneric_OpRound32F_0(v *Value) bool { // match: (Round32F x:(Const32F)) // cond: // result: x @@ -16970,7 +17084,7 @@ func rewriteValuegeneric_OpRound32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpRound64F(v *Value) bool { +func rewriteValuegeneric_OpRound64F_0(v *Value) bool { // match: (Round64F x:(Const64F)) // cond: // result: x @@ -16986,7 +17100,7 @@ func rewriteValuegeneric_OpRound64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool { +func rewriteValuegeneric_OpRsh16Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux16 x (Const16 [c])) @@ -17024,7 +17138,7 @@ func rewriteValuegeneric_OpRsh16Ux16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool { +func rewriteValuegeneric_OpRsh16Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux32 x (Const32 [c])) @@ -17062,7 +17176,7 @@ func rewriteValuegeneric_OpRsh16Ux32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool { +func rewriteValuegeneric_OpRsh16Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -17232,7 +17346,7 @@ func rewriteValuegeneric_OpRsh16Ux64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool { +func rewriteValuegeneric_OpRsh16Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16Ux8 x (Const8 [c])) @@ -17270,7 +17384,7 @@ func rewriteValuegeneric_OpRsh16Ux8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16x16(v *Value) bool { +func rewriteValuegeneric_OpRsh16x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x16 x (Const16 [c])) @@ -17308,7 +17422,7 @@ func rewriteValuegeneric_OpRsh16x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16x32(v *Value) bool { +func rewriteValuegeneric_OpRsh16x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x32 x (Const32 [c])) @@ -17346,7 +17460,7 @@ func rewriteValuegeneric_OpRsh16x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16x64(v *Value) bool { +func rewriteValuegeneric_OpRsh16x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -17462,7 +17576,7 @@ func rewriteValuegeneric_OpRsh16x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh16x8(v *Value) bool { +func rewriteValuegeneric_OpRsh16x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh16x8 x (Const8 [c])) @@ -17500,7 +17614,7 @@ func rewriteValuegeneric_OpRsh16x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool { +func rewriteValuegeneric_OpRsh32Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux16 x (Const16 [c])) @@ -17538,7 +17652,7 @@ func rewriteValuegeneric_OpRsh32Ux16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool { +func rewriteValuegeneric_OpRsh32Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux32 x (Const32 [c])) @@ -17576,7 +17690,7 @@ func rewriteValuegeneric_OpRsh32Ux32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool { +func rewriteValuegeneric_OpRsh32Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -17775,7 +17889,7 @@ func rewriteValuegeneric_OpRsh32Ux64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool { +func rewriteValuegeneric_OpRsh32Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32Ux8 x (Const8 [c])) @@ -17813,7 +17927,7 @@ func rewriteValuegeneric_OpRsh32Ux8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32x16(v *Value) bool { +func rewriteValuegeneric_OpRsh32x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x16 x (Const16 [c])) @@ -17851,7 +17965,7 @@ func rewriteValuegeneric_OpRsh32x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32x32(v *Value) bool { +func rewriteValuegeneric_OpRsh32x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x32 x (Const32 [c])) @@ -17889,7 +18003,7 @@ func rewriteValuegeneric_OpRsh32x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32x64(v *Value) bool { +func rewriteValuegeneric_OpRsh32x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -18034,7 +18148,7 @@ func rewriteValuegeneric_OpRsh32x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh32x8(v *Value) bool { +func rewriteValuegeneric_OpRsh32x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh32x8 x (Const8 [c])) @@ -18072,7 +18186,7 @@ func rewriteValuegeneric_OpRsh32x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool { +func rewriteValuegeneric_OpRsh64Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux16 x (Const16 [c])) @@ -18110,7 +18224,7 @@ func rewriteValuegeneric_OpRsh64Ux16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool { +func rewriteValuegeneric_OpRsh64Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux32 x (Const32 [c])) @@ -18148,7 +18262,7 @@ func rewriteValuegeneric_OpRsh64Ux32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool { +func rewriteValuegeneric_OpRsh64Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -18376,7 +18490,7 @@ func rewriteValuegeneric_OpRsh64Ux64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool { +func rewriteValuegeneric_OpRsh64Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64Ux8 x (Const8 [c])) @@ -18414,7 +18528,7 @@ func rewriteValuegeneric_OpRsh64Ux8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64x16(v *Value) bool { +func rewriteValuegeneric_OpRsh64x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x16 x (Const16 [c])) @@ -18452,7 +18566,7 @@ func rewriteValuegeneric_OpRsh64x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64x32(v *Value) bool { +func rewriteValuegeneric_OpRsh64x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x32 x (Const32 [c])) @@ -18490,7 +18604,7 @@ func rewriteValuegeneric_OpRsh64x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64x64(v *Value) bool { +func rewriteValuegeneric_OpRsh64x64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -18664,7 +18778,7 @@ func rewriteValuegeneric_OpRsh64x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh64x8(v *Value) bool { +func rewriteValuegeneric_OpRsh64x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh64x8 x (Const8 [c])) @@ -18702,7 +18816,7 @@ func rewriteValuegeneric_OpRsh64x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool { +func rewriteValuegeneric_OpRsh8Ux16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux16 x (Const16 [c])) @@ -18740,7 +18854,7 @@ func rewriteValuegeneric_OpRsh8Ux16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool { +func rewriteValuegeneric_OpRsh8Ux32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux32 x (Const32 [c])) @@ -18778,7 +18892,7 @@ func rewriteValuegeneric_OpRsh8Ux32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool { +func rewriteValuegeneric_OpRsh8Ux64_0(v *Value) bool { b := v.Block _ = b types := &b.Func.Config.Types @@ -18919,7 +19033,7 @@ func rewriteValuegeneric_OpRsh8Ux64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool { +func rewriteValuegeneric_OpRsh8Ux8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8Ux8 x (Const8 [c])) @@ -18957,7 +19071,7 @@ func rewriteValuegeneric_OpRsh8Ux8(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8x16(v *Value) bool { +func rewriteValuegeneric_OpRsh8x16_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x16 x (Const16 [c])) @@ -18995,7 +19109,7 @@ func rewriteValuegeneric_OpRsh8x16(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8x32(v *Value) bool { +func rewriteValuegeneric_OpRsh8x32_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x32 x (Const32 [c])) @@ -19033,7 +19147,7 @@ func rewriteValuegeneric_OpRsh8x32(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8x64(v *Value) bool { +func rewriteValuegeneric_OpRsh8x64_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x64 (Const8 [c]) (Const64 [d])) @@ -19118,7 +19232,7 @@ func rewriteValuegeneric_OpRsh8x64(v *Value) bool { } return false } -func rewriteValuegeneric_OpRsh8x8(v *Value) bool { +func rewriteValuegeneric_OpRsh8x8_0(v *Value) bool { b := v.Block _ = b // match: (Rsh8x8 x (Const8 [c])) @@ -19156,7 +19270,7 @@ func rewriteValuegeneric_OpRsh8x8(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt16to32(v *Value) bool { +func rewriteValuegeneric_OpSignExt16to32_0(v *Value) bool { // match: (SignExt16to32 (Const16 [c])) // cond: // result: (Const32 [int64( int16(c))]) @@ -19197,7 +19311,7 @@ func rewriteValuegeneric_OpSignExt16to32(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt16to64(v *Value) bool { +func rewriteValuegeneric_OpSignExt16to64_0(v *Value) bool { // match: (SignExt16to64 (Const16 [c])) // cond: // result: (Const64 [int64( int16(c))]) @@ -19238,7 +19352,7 @@ func rewriteValuegeneric_OpSignExt16to64(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt32to64(v *Value) bool { +func rewriteValuegeneric_OpSignExt32to64_0(v *Value) bool { // match: (SignExt32to64 (Const32 [c])) // cond: // result: (Const64 [int64( int32(c))]) @@ -19279,7 +19393,7 @@ func rewriteValuegeneric_OpSignExt32to64(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt8to16(v *Value) bool { +func rewriteValuegeneric_OpSignExt8to16_0(v *Value) bool { // match: (SignExt8to16 (Const8 [c])) // cond: // result: (Const16 [int64( int8(c))]) @@ -19320,7 +19434,7 @@ func rewriteValuegeneric_OpSignExt8to16(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt8to32(v *Value) bool { +func rewriteValuegeneric_OpSignExt8to32_0(v *Value) bool { // match: (SignExt8to32 (Const8 [c])) // cond: // result: (Const32 [int64( int8(c))]) @@ -19361,7 +19475,7 @@ func rewriteValuegeneric_OpSignExt8to32(v *Value) bool { } return false } -func rewriteValuegeneric_OpSignExt8to64(v *Value) bool { +func rewriteValuegeneric_OpSignExt8to64_0(v *Value) bool { // match: (SignExt8to64 (Const8 [c])) // cond: // result: (Const64 [int64( int8(c))]) @@ -19402,7 +19516,7 @@ func rewriteValuegeneric_OpSignExt8to64(v *Value) bool { } return false } -func rewriteValuegeneric_OpSliceCap(v *Value) bool { +func rewriteValuegeneric_OpSliceCap_0(v *Value) bool { // match: (SliceCap (SliceMake _ _ (Const64 [c]))) // cond: // result: (Const64 [c]) @@ -19477,7 +19591,7 @@ func rewriteValuegeneric_OpSliceCap(v *Value) bool { } return false } -func rewriteValuegeneric_OpSliceLen(v *Value) bool { +func rewriteValuegeneric_OpSliceLen_0(v *Value) bool { // match: (SliceLen (SliceMake _ (Const64 [c]) _)) // cond: // result: (Const64 [c]) @@ -19535,7 +19649,7 @@ func rewriteValuegeneric_OpSliceLen(v *Value) bool { } return false } -func rewriteValuegeneric_OpSlicePtr(v *Value) bool { +func rewriteValuegeneric_OpSlicePtr_0(v *Value) bool { // match: (SlicePtr (SliceMake (SlicePtr x) _ _)) // cond: // result: (SlicePtr x) @@ -19555,7 +19669,7 @@ func rewriteValuegeneric_OpSlicePtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpSlicemask(v *Value) bool { +func rewriteValuegeneric_OpSlicemask_0(v *Value) bool { // match: (Slicemask (Const32 [x])) // cond: x > 0 // result: (Const32 [-1]) @@ -19620,7 +19734,7 @@ func rewriteValuegeneric_OpSlicemask(v *Value) bool { } return false } -func rewriteValuegeneric_OpSqrt(v *Value) bool { +func rewriteValuegeneric_OpSqrt_0(v *Value) bool { // match: (Sqrt (Const64F [c])) // cond: // result: (Const64F [f2i(math.Sqrt(i2f(c)))]) @@ -19636,7 +19750,7 @@ func rewriteValuegeneric_OpSqrt(v *Value) bool { } return false } -func rewriteValuegeneric_OpStore(v *Value) bool { +func rewriteValuegeneric_OpStore_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -19921,6 +20035,13 @@ func rewriteValuegeneric_OpStore(v *Value) bool { v.AddArg(mem) return true } + return false +} +func rewriteValuegeneric_OpStore_10(v *Value) bool { + b := v.Block + _ = b + config := b.Func.Config + _ = config // match: (Store (OffPtr (Load (OffPtr [c] (SP)) mem)) x mem) // cond: isConstZero(x) && mem.Op == OpStaticCall && isSameSym(mem.Aux, "runtime.newobject") && c == config.ctxt.FixedFrameSize() + config.RegSize // result: mem @@ -19957,7 +20078,7 @@ func rewriteValuegeneric_OpStore(v *Value) bool { } return false } -func rewriteValuegeneric_OpStringLen(v *Value) bool { +func rewriteValuegeneric_OpStringLen_0(v *Value) bool { // match: (StringLen (StringMake _ (Const64 [c]))) // cond: // result: (Const64 [c]) @@ -19979,7 +20100,7 @@ func rewriteValuegeneric_OpStringLen(v *Value) bool { } return false } -func rewriteValuegeneric_OpStringPtr(v *Value) bool { +func rewriteValuegeneric_OpStringPtr_0(v *Value) bool { // match: (StringPtr (StringMake (Const64 [c]) _)) // cond: // result: (Const64 [c]) @@ -20001,11 +20122,7 @@ func rewriteValuegeneric_OpStringPtr(v *Value) bool { } return false } -func rewriteValuegeneric_OpStructSelect(v *Value) bool { - b := v.Block - _ = b - fe := b.Func.fe - _ = fe +func rewriteValuegeneric_OpStructSelect_0(v *Value) bool { // match: (StructSelect (StructMake1 x)) // cond: // result: x @@ -20173,6 +20290,13 @@ func rewriteValuegeneric_OpStructSelect(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpStructSelect_10(v *Value) bool { + b := v.Block + _ = b + fe := b.Func.fe + _ = fe // match: (StructSelect [i] x:(Load ptr mem)) // cond: !fe.CanSSA(t) // result: @x.Block (Load (OffPtr [t.FieldOff(int(i))] ptr) mem) @@ -20217,7 +20341,7 @@ func rewriteValuegeneric_OpStructSelect(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub16(v *Value) bool { +func rewriteValuegeneric_OpSub16_0(v *Value) bool { b := v.Block _ = b // match: (Sub16 (Const16 [c]) (Const16 [d])) @@ -20425,6 +20549,11 @@ func rewriteValuegeneric_OpSub16(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpSub16_10(v *Value) bool { + b := v.Block + _ = b // match: (Sub16 (Const16 [c]) (Sub16 (Const16 [d]) x)) // cond: // result: (Add16 (Const16 [int64(int16(c-d))]) x) @@ -20457,7 +20586,7 @@ func rewriteValuegeneric_OpSub16(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub32(v *Value) bool { +func rewriteValuegeneric_OpSub32_0(v *Value) bool { b := v.Block _ = b // match: (Sub32 (Const32 [c]) (Const32 [d])) @@ -20665,6 +20794,11 @@ func rewriteValuegeneric_OpSub32(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpSub32_10(v *Value) bool { + b := v.Block + _ = b // match: (Sub32 (Const32 [c]) (Sub32 (Const32 [d]) x)) // cond: // result: (Add32 (Const32 [int64(int32(c-d))]) x) @@ -20697,7 +20831,7 @@ func rewriteValuegeneric_OpSub32(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub32F(v *Value) bool { +func rewriteValuegeneric_OpSub32F_0(v *Value) bool { // match: (Sub32F (Const32F [c]) (Const32F [d])) // cond: // result: (Const32F [f2i(float64(i2f32(c) - i2f32(d)))]) @@ -20735,7 +20869,7 @@ func rewriteValuegeneric_OpSub32F(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub64(v *Value) bool { +func rewriteValuegeneric_OpSub64_0(v *Value) bool { b := v.Block _ = b // match: (Sub64 (Const64 [c]) (Const64 [d])) @@ -20943,6 +21077,11 @@ func rewriteValuegeneric_OpSub64(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpSub64_10(v *Value) bool { + b := v.Block + _ = b // match: (Sub64 (Const64 [c]) (Sub64 (Const64 [d]) x)) // cond: // result: (Add64 (Const64 [c-d]) x) @@ -20975,7 +21114,7 @@ func rewriteValuegeneric_OpSub64(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub64F(v *Value) bool { +func rewriteValuegeneric_OpSub64F_0(v *Value) bool { // match: (Sub64F (Const64F [c]) (Const64F [d])) // cond: // result: (Const64F [f2i(i2f(c) - i2f(d))]) @@ -21013,7 +21152,7 @@ func rewriteValuegeneric_OpSub64F(v *Value) bool { } return false } -func rewriteValuegeneric_OpSub8(v *Value) bool { +func rewriteValuegeneric_OpSub8_0(v *Value) bool { b := v.Block _ = b // match: (Sub8 (Const8 [c]) (Const8 [d])) @@ -21221,6 +21360,11 @@ func rewriteValuegeneric_OpSub8(v *Value) bool { v.AddArg(x) return true } + return false +} +func rewriteValuegeneric_OpSub8_10(v *Value) bool { + b := v.Block + _ = b // match: (Sub8 (Const8 [c]) (Sub8 (Const8 [d]) x)) // cond: // result: (Add8 (Const8 [int64(int8(c-d))]) x) @@ -21253,7 +21397,7 @@ func rewriteValuegeneric_OpSub8(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc16to8(v *Value) bool { +func rewriteValuegeneric_OpTrunc16to8_0(v *Value) bool { // match: (Trunc16to8 (Const16 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -21339,7 +21483,7 @@ func rewriteValuegeneric_OpTrunc16to8(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc32to16(v *Value) bool { +func rewriteValuegeneric_OpTrunc32to16_0(v *Value) bool { // match: (Trunc32to16 (Const32 [c])) // cond: // result: (Const16 [int64(int16(c))]) @@ -21451,7 +21595,7 @@ func rewriteValuegeneric_OpTrunc32to16(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc32to8(v *Value) bool { +func rewriteValuegeneric_OpTrunc32to8_0(v *Value) bool { // match: (Trunc32to8 (Const32 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -21537,7 +21681,7 @@ func rewriteValuegeneric_OpTrunc32to8(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc64to16(v *Value) bool { +func rewriteValuegeneric_OpTrunc64to16_0(v *Value) bool { // match: (Trunc64to16 (Const64 [c])) // cond: // result: (Const16 [int64(int16(c))]) @@ -21649,7 +21793,7 @@ func rewriteValuegeneric_OpTrunc64to16(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc64to32(v *Value) bool { +func rewriteValuegeneric_OpTrunc64to32_0(v *Value) bool { // match: (Trunc64to32 (Const64 [c])) // cond: // result: (Const32 [int64(int32(c))]) @@ -21787,7 +21931,7 @@ func rewriteValuegeneric_OpTrunc64to32(v *Value) bool { } return false } -func rewriteValuegeneric_OpTrunc64to8(v *Value) bool { +func rewriteValuegeneric_OpTrunc64to8_0(v *Value) bool { // match: (Trunc64to8 (Const64 [c])) // cond: // result: (Const8 [int64(int8(c))]) @@ -21873,7 +22017,7 @@ func rewriteValuegeneric_OpTrunc64to8(v *Value) bool { } return false } -func rewriteValuegeneric_OpXor16(v *Value) bool { +func rewriteValuegeneric_OpXor16_0(v *Value) bool { b := v.Block _ = b // match: (Xor16 (Const16 [c]) (Const16 [d])) @@ -22056,6 +22200,11 @@ func rewriteValuegeneric_OpXor16(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpXor16_10(v *Value) bool { + b := v.Block + _ = b // match: (Xor16 (Xor16 z i:(Const16 )) x) // cond: (z.Op != OpConst16 && x.Op != OpConst16) // result: (Xor16 i (Xor16 z x)) @@ -22256,7 +22405,7 @@ func rewriteValuegeneric_OpXor16(v *Value) bool { } return false } -func rewriteValuegeneric_OpXor32(v *Value) bool { +func rewriteValuegeneric_OpXor32_0(v *Value) bool { b := v.Block _ = b // match: (Xor32 (Const32 [c]) (Const32 [d])) @@ -22439,6 +22588,11 @@ func rewriteValuegeneric_OpXor32(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpXor32_10(v *Value) bool { + b := v.Block + _ = b // match: (Xor32 (Xor32 z i:(Const32 )) x) // cond: (z.Op != OpConst32 && x.Op != OpConst32) // result: (Xor32 i (Xor32 z x)) @@ -22639,7 +22793,7 @@ func rewriteValuegeneric_OpXor32(v *Value) bool { } return false } -func rewriteValuegeneric_OpXor64(v *Value) bool { +func rewriteValuegeneric_OpXor64_0(v *Value) bool { b := v.Block _ = b // match: (Xor64 (Const64 [c]) (Const64 [d])) @@ -22822,6 +22976,11 @@ func rewriteValuegeneric_OpXor64(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpXor64_10(v *Value) bool { + b := v.Block + _ = b // match: (Xor64 (Xor64 z i:(Const64 )) x) // cond: (z.Op != OpConst64 && x.Op != OpConst64) // result: (Xor64 i (Xor64 z x)) @@ -23022,7 +23181,7 @@ func rewriteValuegeneric_OpXor64(v *Value) bool { } return false } -func rewriteValuegeneric_OpXor8(v *Value) bool { +func rewriteValuegeneric_OpXor8_0(v *Value) bool { b := v.Block _ = b // match: (Xor8 (Const8 [c]) (Const8 [d])) @@ -23205,6 +23364,11 @@ func rewriteValuegeneric_OpXor8(v *Value) bool { v.AddArg(v0) return true } + return false +} +func rewriteValuegeneric_OpXor8_10(v *Value) bool { + b := v.Block + _ = b // match: (Xor8 (Xor8 z i:(Const8 )) x) // cond: (z.Op != OpConst8 && x.Op != OpConst8) // result: (Xor8 i (Xor8 z x)) @@ -23405,7 +23569,7 @@ func rewriteValuegeneric_OpXor8(v *Value) bool { } return false } -func rewriteValuegeneric_OpZero(v *Value) bool { +func rewriteValuegeneric_OpZero_0(v *Value) bool { b := v.Block _ = b config := b.Func.Config @@ -23441,7 +23605,7 @@ func rewriteValuegeneric_OpZero(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool { +func rewriteValuegeneric_OpZeroExt16to32_0(v *Value) bool { // match: (ZeroExt16to32 (Const16 [c])) // cond: // result: (Const32 [int64(uint16(c))]) @@ -23482,7 +23646,7 @@ func rewriteValuegeneric_OpZeroExt16to32(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool { +func rewriteValuegeneric_OpZeroExt16to64_0(v *Value) bool { // match: (ZeroExt16to64 (Const16 [c])) // cond: // result: (Const64 [int64(uint16(c))]) @@ -23523,7 +23687,7 @@ func rewriteValuegeneric_OpZeroExt16to64(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool { +func rewriteValuegeneric_OpZeroExt32to64_0(v *Value) bool { // match: (ZeroExt32to64 (Const32 [c])) // cond: // result: (Const64 [int64(uint32(c))]) @@ -23564,7 +23728,7 @@ func rewriteValuegeneric_OpZeroExt32to64(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool { +func rewriteValuegeneric_OpZeroExt8to16_0(v *Value) bool { // match: (ZeroExt8to16 (Const8 [c])) // cond: // result: (Const16 [int64( uint8(c))]) @@ -23605,7 +23769,7 @@ func rewriteValuegeneric_OpZeroExt8to16(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool { +func rewriteValuegeneric_OpZeroExt8to32_0(v *Value) bool { // match: (ZeroExt8to32 (Const8 [c])) // cond: // result: (Const32 [int64( uint8(c))]) @@ -23646,7 +23810,7 @@ func rewriteValuegeneric_OpZeroExt8to32(v *Value) bool { } return false } -func rewriteValuegeneric_OpZeroExt8to64(v *Value) bool { +func rewriteValuegeneric_OpZeroExt8to64_0(v *Value) bool { // match: (ZeroExt8to64 (Const8 [c])) // cond: // result: (Const64 [int64( uint8(c))])