mirror of https://github.com/golang/go.git
cmd/compile: break up large value rewrite functions
This makes the cmd/compile/internal/ssa package compile much faster, and has no impact on the speed of the compiler. The chunk size was selected empirically, in that at chunk size 10, the object file was smaller than at chunk size 5 or 20. name old time/op new time/op delta SSA 7.33s ± 5% 5.64s ± 1% -23.10% (p=0.000 n=10+10) name old user-time/op new user-time/op delta SSA 9.70s ± 1% 8.04s ± 2% -17.17% (p=0.000 n=9+10) name old obj-bytes new obj-bytes delta SSA 9.82M ± 0% 8.28M ± 0% -15.67% (p=0.000 n=10+10) Change-Id: Iab472905da3f0e82f3db2c93d06e2759abc9dd44 Reviewed-on: https://go-review.googlesource.com/41296 Reviewed-by: Keith Randall <khr@golang.org>
This commit is contained in:
Josh Bleecher Snyder
parent
eaa198f3d1
commit
fc7b83d192
|
|
@ -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
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
File diff suppressed because it is too large
Load Diff
|
|
@ -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
|
||||
|
|
|
|||
|
|
@ -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 <t> 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
|
||||
|
|
|
|||
File diff suppressed because it is too large
Load Diff
Loading…
Reference in New Issue